文章总结： 本文详细分析了2025强网拟态决赛MimicWorld逆向题目，通过PE文件解析提取虚拟机字节码，使用LCG算法解密，分析虚拟机架构和TEA加密变种，最终逆向推导出解密算法获取flag。文章提供了完整的技术路线图、关键代码实现和验证方法，展示了从文件格式分析到算法破解的系统性逆向工程思路，对学习虚拟机保护和加密算法逆向有重要参考价值。
综合评分： 90
文章分类： CTF,逆向分析,二进制安全
解析2025强网拟态决赛MimicWorld
原创
破镜安全
破镜安全
2025年12月12日 08:01
北京
MimicWorld – 虚拟机保护与TEA加密的逆向分析
前言
本文详细分析一道综合性的CTF逆向题目，涉及PE文件解析、虚拟机保护、流加密、分组加密等多个技术点。题目难度适中，非常适合学习虚拟机逆向和加密算法分析。
文章将从零开始，逐步分析程序结构，解密字节码，理解虚拟机执行流程，最终破解加密算法获得flag。所有步骤都会详细说明技术原理，确保初学者也能跟随并理解。
一、初步侦察
1.1 文件基本信息
拿到题目后，首先查看文件类型：
file MimicWorld.exe
输出结果：
MimicWorld.exe: PE32+ executable (GUI) x86-64, for MS Windows, 6 sections
关键信息：
- 文件格式：PE32+（64位Windows可执行文件）
- 架构：x86-64
- 节数量：6个
这说明我们面对的是一个标准的Windows 64位程序。
1.2 为什么不能直接运行？
在Linux环境下，我们无法直接运行这个Windows程序。虽然可以使用Wine等工具，但对于逆向分析来说，静态分析往往更加高效和安全。因此我们选择：
- 静态分析PE文件结构
- 提取关键数据
- 编写Python脚本模拟执行
这种方法的优点是：
- 不需要Windows环境
- 可以完全控制分析流程
- 避免潜在的恶意行为
- 便于自动化处理
1.3 字符串分析
使用strings命令查看程序中的可见字符串：
strings MimicWorld.exe | head -50
经过检查，程序中没有明显的flag或关键提示信息。这说明关键逻辑被隐藏或加密了，需要深入分析。
二、PE文件结构深度解析
2.1 PE文件格式概述
PE（Portable Executable）是Windows系统的可执行文件格式。理解PE结构对于逆向分析至关重要。
PE文件的基本结构：
+------------------+
| DOS Header | <- 兼容性头部
+------------------+
| DOS Stub | <- DOS存根程序
+------------------+
| PE Signature | <- "PE\0\0"标识
+------------------+
| File Header | <- COFF文件头
+------------------+
| Optional Header | <- 可选头（实际必需）
+------------------+
| Section Table | <- 节表
+------------------+
| Section 1 (.text)| <- 代码段
+------------------+
| Section 2 (.data)| <- 数据段
+------------------+
| Section 3 (.rdata)| <- 只读数据段
+------------------+
| ... |
+------------------+
2.2 为什么需要手动解析PE文件？
在逆向分析中，我们经常需要提取程序中的特定数据。对于本题：
- 程序包含加密的虚拟机字节码
- 字节码存储在某个数据段中
- 我们需要找到并提取这些数据
通过IDA Pro等工具可以定位到数据的虚拟地址（Virtual Address），但要从文件中提取，需要将虚拟地址转换为文件偏移（File Offset）。
2.3 虚拟地址到文件偏移的转换
关键概念：
- 虚拟地址（VA）：程序加载到内存后的地址，例如 0x140042A80
- 相对虚拟地址（RVA）：相对于基地址的偏移，例如 0x42A80（减去基地址0x140000000）
- 文件偏移（File Offset）：数据在文件中的实际位置
转换公式：
File Offset = Section Raw Offset + (RVA - Section Virtual Address)
2.4 节表结构解析
节表是一个数组，每个条目40字节，描述一个节的信息：
struct SectionHeader {
char Name[8]; // 节名称
DWORD VirtualSize; // 内存中的大小
DWORD VirtualAddress; // 内存中的RVA
DWORD SizeOfRawData; // 文件中的大小
DWORD PointerToRawData; // 文件中的偏移
// ... 其他字段
};
2.5 编写数据提取脚本
现在我们可以编写Python脚本来提取VM字节码。通过静态分析工具，我们已知：
- 目标数据的RVA：0x42A80
- 数据大小：0x5407字节（21511字节）
完整的提取脚本：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PE文件数据提取脚本
功能：从MimicWorld.exe中提取VM字节码
"""
def extract_vm_bytecode():
# 1. 读取整个PE文件
with open('MimicWorld.exe', 'rb') as f:
pe_data = f.read()
# 2. 读取PE头偏移
# DOS头的0x3C偏移处存储PE头的位置
pe_offset = int.from_bytes(pe_data[0x3C:0x3C+4], 'little')
print(f"[+] PE头偏移: 0x{pe_offset:X}")
# 3. 读取节表数量
# PE头偏移+6处是节数量（2字节）
number_of_sections = int.from_bytes(pe_data[pe_offset+6:pe_offset+8], 'little')
print(f"[+] 节表数量: {number_of_sections}")
# 4. 读取可选头大小
# PE头偏移+20处是可选头大小（2字节）
size_of_optional_header = int.from_bytes(pe_data[pe_offset+20:pe_offset+22], 'little')
print(f"[+] 可选头大小: 0x{size_of_optional_header:X}")
# 5. 计算节表开始位置
# 节表在：PE签名(4) + 文件头(20) + 可选头之后
section_table_offset = pe_offset + 24 + size_of_optional_header
# 6. 目标数据信息
target_rva = 0x42A80 # 目标RVA
data_size = 0x5407 # 数据大小
print(f"\n[+] 目标 RVA: 0x{target_rva:X}, 大小: 0x{data_size:X}")
print("\n[+] 节表信息:")
# 7. 遍历节表，查找包含目标RVA的节
for i in range(number_of_sections):
# 每个节表条目40字节
section_offset = section_table_offset + i * 40
# 读取节信息
section_name = pe_data[section_offset:section_offset+8].rstrip(b'\x00').decode('ascii', errors='ignore')
virtual_size = int.from_bytes(pe_data[section_offset+8:section_offset+12], 'little')
virtual_address = int.from_bytes(pe_data[section_offset+12:section_offset+16], 'little')
size_of_raw_data = int.from_bytes(pe_data[section_offset+16:section_offset+20], 'little')
pointer_to_raw_data = int.from_bytes(pe_data[section_offset+20:section_offset+24], 'little')
print(f" [{i}] {section_name:8s} VirtAddr: 0x{virtual_address:08X} VirtSize: 0x{virtual_size:08X} "
f"RawAddr: 0x{pointer_to_raw_data:08X} RawSize: 0x{size_of_raw_data:08X}")
# 8. 检查目标RVA是否在这个节的范围内
if virtual_address <= target_rva < virtual_address + virtual_size:
# 9. 计算文件偏移
file_offset = pointer_to_raw_data + (target_rva - virtual_address)
print(f"\n[+] 找到目标节: {section_name}")
print(f"[+] 计算过程:")
print(f" RVA: 0x{target_rva:X}")
print(f" 节虚拟地址: 0x{virtual_address:X}")
print(f" 节内偏移: 0x{target_rva - virtual_address:X}")
print(f" 节文件偏移: 0x{pointer_to_raw_data:X}")
print(f" 最终文件偏移: 0x{file_offset:X}")
# 10. 提取数据
vm_bytecode = pe_data[file_offset:file_offset+data_size]
print(f"\n[+] 成功提取 {len(vm_bytecode)} 字节数据")
# 11. 保存为十六进制字符串
with open('vm_bytecode.hex', 'w') as f:
f.write(vm_bytecode.hex())
print(f"[+] 数据已保存到 vm_bytecode.hex")
return vm_bytecode.hex()
return None
if __name__ == '__main__':
extract_vm_bytecode()
运行脚本：
python3 extract_data.py
输出结果：
[+] PE头偏移: 0x78
[+] 节表数量: 6
[+] 可选头大小: 0xF0
[+] 目标 RVA: 0x42A80, 大小: 0x5407
[+] 节表信息:
[0] .text VirtAddr: 0x00001000 VirtSize: 0x0003F956 RawAddr: 0x00000400 RawSize: 0x0003FA00
[1] .rdata VirtAddr: 0x00041000 VirtSize: 0x000161F0 RawAddr: 0x0003FE00 RawSize: 0x00016200
[+] 找到目标节: .rdata
[+] 文件偏移: 0x41880
[+] 成功提取 21511 字节数据
我们成功从.rdata（只读数据）节中提取了21511字节的数据。这段数据就是加密的VM字节码。
三、流加密解密 – LCG算法
3.1 加密的必要性
为什么程序要加密字节码？这是一种常见的代码保护技术：
- 防止静态分析：加密后的字节码无法直接理解
- 增加逆向难度：需要先理解加密算法才能分析VM
- 对抗反编译：即使提取数据也无法直接使用
3.2 LCG算法原理
通过静态分析程序的解密函数，我们识别出使用了LCG（Linear Congruential Generator）算法生成密钥流。
LCG是什么？
LCG是一种伪随机数生成器，广泛用于快速生成伪随机序列。其递推公式为：
X(n+1) = (a * X(n) + c) mod m
参数说明：
- X(n)：当前状态（种子）
- a：乘数（multiplier）
- c：增量（increment）
- m：模数（modulus）
- X(0)：初始种子
本题使用的LCG参数：
通过逆向分析得到：
初始种子: 0xDEADBEEF
a = 1664525
c = 1013904223
m = 2^32（通过 & 0xFFFFFFFF 实现）
这些参数实际上是著名的Numerical Recipes中推荐的LCG参数，质量较好。
3.3 流加密原理
程序使用LCG生成的伪随机数作为密钥流，与原始数据进行XOR运算：
密文[i] = 明文[i] XOR LOBYTE(Seed[i])
其中：
- LOBYTE(Seed[i])：取种子的最低字节（0-255）
- XOR：异或运算
为什么用XOR？
XOR运算有一个重要特性：
A XOR B XOR B = A
这意味着加密和解密使用完全相同的算法，只需要用相同的密钥流再次XOR即可。
3.4 解密算法实现
完整的解密脚本：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VM字节码解密脚本
使用LCG算法生成密钥流并解密
"""
import struct
def decrypt_vm_bytecode(hex_data):
"""
解密VM字节码
参数:
hex_data: 十六进制字符串格式的加密数据
返回:
解密后的字节列表
"""
print("[+] 开始解密VM字节码...")
# 1. 将十六进制字符串转换为字节数组
raw_bytes = bytes.fromhex(hex_data.replace(' ', '').replace('\n', ''))
print(f"[+] 原始数据大小: {len(raw_bytes)} 字节")
# 2. 初始化
decrypted_code = []
seed = 0xDEADBEEF # 初始种子
# 3. 逐字节解密
for i, encrypted_byte in enumerate(raw_bytes):
# 3.1 生成当前字节的密钥（取种子的最低字节）
key_byte = seed & 0xFF
# 3.2 解密：密文 XOR 密钥 = 明文
decrypted_byte = (encrypted_byte ^ key_byte) & 0xFF
decrypted_code.append(decrypted_byte)
# 3.3 更新种子（LCG算法）
seed = (1664525 * seed + 1013904223) & 0xFFFFFFFF
# 3.4 每1000字节显示一次进度
if (i + 1) % 1000 == 0:
print(f" 已处理: {i+1}/{len(raw_bytes)} 字节")
print(f"[+] 解密完成，得到 {len(decrypted_code)} 字节明文")
return decrypted_code
算法步骤详解：
- 读取加密数据：将十六进制字符串转为字节数组
- 初始化种子：设置seed = 0xDEADBEEF
- 对每个字节：
- 取种子的最低字节作为密钥
- 使用XOR解密
- 更新种子（LCG公式）
- 返回解密结果
四、虚拟机架构分析
4.1 什么是虚拟机保护？
虚拟机（VM）保护是一种代码混淆技术：
- 定义自定义指令集：不使用x86等真实指令
- 编写虚拟机解释器：在运行时解释执行虚拟指令
- 保护关键逻辑：将关键算法编译为虚拟指令
优点：
- 大幅增加逆向难度
- 隐藏真实算法逻辑
- 可以实现代码变形
缺点：
- 执行效率低
- 增加程序体积
4.2 VM指令格式分析
通过分析解密后的字节码，我们发现每条指令固定为7字节：
+--------+--------+--------+--------------------+
| Opcode | P1 | P2 | Immediate |
| (1字节)| (1字节)| (1字节)| (4字节) |
+--------+--------+--------+--------------------+
字段说明：
- Opcode：操作码，决定指令类型（0-11）
- P1：参数1，通常是目标寄存器编号
- P2：参数2，通常是源寄存器编号
- Immediate：32位立即数，小端序存储
4.3 VM指令集定义
通过逆向分析VM解释器函数，识别出12种指令：
| 操作码 | 助记符 | 格式 | 功能说明 |
| — | — | — | — |
| 0 | EXIT | – | 退出虚拟机 |
| 1 | MOV | Rx, INPUT[Ry] | 从输入数组读取数据到寄存器 |
| 2 | MOV | Rx, imm | 加载立即数到寄存器 |
| 3 | MOV | Rx, Ry | 寄存器间复制 |
| 4 | XOR | Rx, Ry | 寄存器间异或：Rx ^= Ry |
| 5 | ADD | Rx, Ry | 寄存器间加法：Rx += Ry |
| 6 | SHL | Rx, imm | 左移：Rx <<= imm |
| 7 | SHR | Rx, imm | 右移：Rx >>= imm |
| 8 | XOR | Rx, imm | 立即数异或：Rx ^= imm |
| 9 | ADD | Rx, imm | 立即数加法：Rx += imm |
| 10 | CMP | Rx, imm | 比较（校验点）：检查Rx是否等于imm |
| 11 | INC | Rx | 自增：Rx++ |
4.4 反汇编器实现
编写VM反汇编器：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VM指令反汇编器
将字节码转换为可读的汇编代码
"""
import struct
def disassemble_vm_code(decrypted_code, output_file):
"""
反汇编VM指令
参数:
decrypted_code: 解密后的字节码列表
output_file: 输出文件路径
"""
print(f"[+] 开始反汇编，结果将保存到: {output_file}")
with open(output_file, "w", encoding="utf-8") as f:
# 写入文件头
f.write(";; MimicWorld VM Disassembly\n")
f.write(";; " + "=" * 58 + "\n")
f.write(";; 指令格式: [地址] 操作码 操作数\n")
f.write(";; " + "=" * 58 + "\n\n")
pc = 0 # 程序计数器（Program Counter）
instruction_count = 0
while pc < len(decrypted_code):
# 检查剩余长度是否足够一条指令
if pc + 7 > len(decrypted_code):
f.write(f"\n;; 警告: 剩余 {len(decrypted_code) - pc} 字节，不足7字节\n")
break
# 解析指令各字段
opcode = decrypted_code[pc]
p1 = decrypted_code[pc + 1]
p2 = decrypted_code[pc + 2]
# 解析4字节立即数（小端序）
imm_bytes = bytes(decrypted_code[pc+3:pc+7])
imm = struct.unpack('<I', imm_bytes)[0]
# 构建反汇编代码
addr_str = f"[0x{pc:04X}] "
# 根据操作码生成对应的汇编指令
if opcode == 0:
asm_line = "EXIT ; 程序正常退出"
f.write(addr_str + asm_line + "\n")
break # 遇到EXIT指令停止
elif opcode == 1:
asm_line = f"MOV R{p1}, INPUT[R{p2}] ; 从输入读取"
elif opcode == 2:
asm_line = f"MOV R{p1}, 0x{imm:X}"
# 如果立即数看起来像常量，添加注释
if imm in [0x1337CAFE, 0xDEADBEEF, 0x8BADF00D, 0xFEEDC0DE, 0x7FC3951D]:
asm_line += " ; 魔数常量"
elif opcode == 3:
asm_line = f"MOV R{p1}, R{p2}"
elif opcode == 4:
asm_line = f"XOR R{p1}, R{p2} ; R{p1} ^= R{p2}"
elif opcode == 5:
asm_line = f"ADD R{p1}, R{p2} ; R{p1} += R{p2}"
elif opcode == 6:
asm_line = f"SHL R{p1}, 0x{imm:X} ; R{p1} <<= {imm}"
elif opcode == 7:
asm_line = f"SHR R{p1}, 0x{imm:X} ; R{p1} >>= {imm}"
elif opcode == 8:
asm_line = f"XOR R{p1}, 0x{imm:X} ; R{p1} ^= 0x{imm:X}"
elif opcode == 9:
asm_line = f"ADD R{p1}, 0x{imm:X} ; R{p1} += 0x{imm:X}"
elif opcode == 10:
# CMP指令是关键的校验点
asm_line = f"CMP R{p1}, 0x{imm:08X} ; *** 校验点 ***"
elif opcode == 11:
asm_line = f"INC R{p1} ; R{p1}++"
else:
asm_line = f"UNKNOWN_OP_{opcode} ; 未知操作码"
# 写入反汇编结果
f.write(addr_str + asm_line + "\n")
# PC前进到下一条指令
pc += 7
instruction_count += 1
# 写入统计信息
f.write(f"\n;; " + "=" * 58 + "\n")
f.write(f";; 总指令数: {instruction_count}\n")
f.write(f";; 字节码大小: {len(decrypted_code)} 字节\n")
print(f"[+] 反汇编完成")
print(f"[+] 总指令数: {instruction_count}")
运行反汇编器后，得到3072条VM指令。
4.5 VM执行流程分析
查看反汇编代码的开头部分：
[0x0000] MOV R7, 0x0
[0x0007] MOV R0, INPUT[R7] ; 读取INPUT[0]
[0x000E] MOV R7, 0x1
[0x0015] MOV R7, INPUT[R7] ; 读取INPUT[1]
[0x001C] SHL R7, 0x8 ; 左移8位
[0x0023] ADD R0, R7 ; 组合成16位
[0x002A] MOV R7, 0x2
[0x0031] MOV R7, INPUT[R7] ; 读取INPUT[2]
[0x0038] SHL R7, 0x10 ; 左移16位
[0x003F] ADD R0, R7 ; 继续组合
[0x0046] MOV R7, 0x3
[0x004D] MOV R7, INPUT[R7] ; 读取INPUT[3]
[0x0054] SHL R7, 0x18 ; 左移24位
[0x005B] ADD R0, R7 ; 完成32位整数组合
这段代码的功能：
将输入的前4个字节（INPUT[0]到INPUT[3]）组合成一个32位整数存入R0，使用小端序：
R0 = INPUT[0] | (INPUT[1] << 8) | (INPUT[2] << 16) | (INPUT[3] << 24)
类似的代码将INPUT[4]到INPUT[7]组合成R1。
小端序（Little Endian）解释：
在小端序中，低位字节存储在低地址：
地址: 0 1 2 3
内容: 0x66 0x6C 0x61 0x67
整数: 0x67616C66 (即"flag"的ASCII码倒序)
五、TEA加密算法分析
5.1 识别加密模式
继续查看反汇编代码，发现大量重复的指令模式：
[0x00CB] MOV R2, 0x0
[0x00D2] MOV R3, 0x7FC3951D ; DELTA常量
[0x00D9] ADD R2, R3 ; R2 += DELTA
;; 第一组运算（处理R1，更新R0）
[0x00E0] MOV R4, R1
[0x00E7] SHL R4, 0x5 ; R4 = R1 << 5
[0x00EE] ADD R4, 0x1337CAFE ; R4 += 0x1337CAFE
[0x00F5] MOV R5, R1
[0x00FC] ADD R5, R2 ; R5 = R1 + R2
[0x0103] MOV R6, R1
[0x010A] SHR R6, 0x3 ; R6 = R1 >> 3
[0x0111] ADD R6, 0xDEADBEEF ; R6 += 0xDEADBEEF
[0x0118] XOR R4, R5 ; R4 ^= R5
[0x011F] XOR R4, R6 ; R4 ^= R6
[0x0126] ADD R0, R4 ; R0 += R4
;; 第二组运算（处理R0，更新R1）
[0x012D] MOV R4, R0
[0x0134] SHL R4, 0x5 ; R4 = R0 << 5
[0x013B] ADD R4, 0x8BADF00D ; R4 += 0x8BADF00D
[0x0142] MOV R5, R0
[0x0149] ADD R5, R2 ; R5 = R0 + R2
[0x0150] MOV R6, R0
[0x0157] SHR R6, 0x3 ; R6 = R0 >> 3
[0x015E] ADD R6, 0xFEEDC0DE ; R6 += 0xFEEDC0DE
[0x0165] XOR R4, R5 ; R4 ^= R5
[0x016C] XOR R4, R6 ; R4 ^= R6
[0x0173] ADD R1, R4 ; R1 += R4
;; 继续下一轮
[0x017A] ADD R2, R3 ; R2 += DELTA
...
这种模式重复32次后，出现CMP指令。
5.2 TEA算法原理
通过分析这些指令的模式，识别出这是TEA（Tiny Encryption Algorithm）的变种。
标准TEA算法：
TEA是一种分组密码，特点是：
- 分组大小：64位（8字节）
- 密钥大小：128位（16字节）
- 迭代轮数：通常32轮
- 结构：Feistel网络
标准TEA加密伪代码：
void tea_encrypt(uint32_t v[2], uint32_t k[4]) {
uint32_t v0 = v[0], v1 = v[1];
uint32_t sum = 0;
uint32_t delta = 0x9E3779B9;
for (int i = 0; i < 32; i++) {
sum += delta;
v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
}
v[0] = v0;
v[1] = v1;
}
5.3 本题的TEA变种
本题的实现有所不同：
- DELTA值不同：使用0x7FC3951D而非标准的0x9E3779B9
- 密钥嵌入代码：密钥以常量形式硬编码
- 移位量不同：使用<<5和>>3，而非<<4和>>5
加密函数F（处理R1，更新R0）：
def F(v, k):
"""
TEA变种的F函数
v: 输入值（R1）
k: 密钥（R2）
"""
r4 = ((v << 5) + 0x1337CAFE) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xDEADBEEF) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
加密函数G（处理R0，更新R1）：
def G(v, k):
"""
TEA变种的G函数
v: 输入值（R0）
k: 密钥（R2）
"""
r4 = ((v << 5) + 0x8BADF00D) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xFEEDC0DE) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
加密流程：
# 初始化
R0 = INPUT[0:3]组成的32位整数
R1 = INPUT[4:7]组成的32位整数
R2 = 0
DELTA = 0x7FC3951D
# 32轮加密
for round in range(1, 33):
R2 = (R2 + DELTA) & 0xFFFFFFFF
R0 = (R0 + F(R1, R2)) & 0xFFFFFFFF
R1 = (R1 + G(R0, R2)) & 0xFFFFFFFF
5.4 提取校验值
搜索CMP指令，找到校验点：
grep "CMP" vm_disassembly.txt
结果：
[0x14F2] CMP R0, 0xC1636AF0 ; *** 校验点 ***
[0x14F9] CMP R1, 0x66011374 ; *** 校验点 ***
[0x29F2] CMP R0, 0x7C1868BD ; *** 校验点 ***
[0x29F9] CMP R1, 0xBE23BA8D ; *** 校验点 ***
[0x3EF2] CMP R0, 0x9E9765E2 ; *** 校验点 ***
[0x3EF9] CMP R1, 0x16C7A9B0 ; *** 校验点 ***
[0x53F2] CMP R0, 0x70DB4A7E ; *** 校验点 ***
[0x53F9] CMP R1, 0xBEBE3372 ; *** 校验点 ***
分析：
- 共有8个CMP指令，分为4组
- 每组检查R0和R1的值
- 这说明输入被分为4组，每组8字节
- 总输入长度：4 × 8 = 32字节
4组密文：
组1: R0=0xC1636AF0, R1=0x66011374
组2: R0=0x7C1868BD, R1=0xBE23BA8D
组3: R0=0x9E9765E2, R1=0x16C7A9B0
组4: R0=0x70DB4A7E, R1=0xBEBE3372
六、解密算法推导
6.1 加密与解密的关系
对于TEA类算法，加密和解密是相反的过程。
加密过程：
for round = 1 to 32:
k = round * DELTA
R0 += F(R1, k)
R1 += G(R0, k) // 注意：这里用的是更新后的R0
解密推导：
要逆向这个过程，需要从最后一轮倒推回第一轮。
设加密后的值为(R0_enc, R1_enc)，我们要求(R0_plain, R1_plain)。
关键观察：
在第i轮加密中：
- 先更新R0：
R0_new = R0_old + F(R1_old, k) - 再更新R1：
R1_new = R1_old + G(R0_new, k)
解密时必须反向操作：
- 先撤销R1的更新：
R1_old = R1_new - G(R0_new, k) - 再撤销R0的更新：
R0_old = R0_new - F(R1_old, k)
注意顺序和使用的值！
6.2 解密算法实现
完整的解密脚本：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
TEA变种解密算法
从密文恢复明文
"""
def F(v, k):
"""
TEA变种的F函数
所有运算都是32位无符号整数
"""
r4 = ((v << 5) + 0x1337CAFE) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xDEADBEEF) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
def G(v, k):
"""
TEA变种的G函数
所有运算都是32位无符号整数
"""
r4 = ((v << 5) + 0x8BADF00D) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xFEEDC0DE) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
def decrypt_block(r0_encrypted, r1_encrypted):
"""
解密一个8字节数据块
参数:
r0_encrypted: 加密后的R0值
r1_encrypted: 加密后的R1值
返回:
(r0_plain, r1_plain): 明文的R0和R1值
"""
DELTA = 0x7FC3951D
r0 = r0_encrypted
r1 = r1_encrypted
print(f" 加密值: R0=0x{r0:08X}, R1=0x{r1:08X}")
# 从第32轮倒推回第1轮
for round_num in range(32, 0, -1):
# 计算当前轮的密钥
k = (round_num * DELTA) & 0xFFFFFFFF
# 步骤1: 撤销R1的更新
# 加密时: R1_new = R1_old + G(R0_new, k)
# 解密时: R1_old = R1_new - G(R0_new, k)
r1 = (r1 - G(r0, k)) & 0xFFFFFFFF
# 步骤2: 撤销R0的更新
# 加密时: R0_new = R0_old + F(R1_old, k)
# 解密时: R0_old = R0_new - F(R1_old, k)
# 注意：这里使用的是步骤1中恢复的R1_old
r0 = (r0 - F(r1, k)) & 0xFFFFFFFF
print(f" 解密值: R0=0x{r0:08X}, R1=0x{r1:08X}")
return r0, r1
def main():
"""
解密所有数据块并拼接成flag
"""
print("=" * 60)
print("MimicWorld Flag 解密工具")
print("=" * 60)
print()
# 从VM反汇编中提取的4组密文
ciphertexts = [
(0xC1636AF0, 0x66011374),
(0x7C1868BD, 0xBE23BA8D),
(0x9E9765E2, 0x16C7A9B0),
(0x70DB4A7E, 0xBEBE3372),
]
flag_parts = []
print("[+] 开始解密4组数据块...\n")
for i, (c0, c1) in enumerate(ciphertexts):
print(f"[数据块 {i+1}/4]")
# 解密当前块
p0, p1 = decrypt_block(c0, c1)
# 将32位整数转换为4字节（小端序）
bytes0 = p0.to_bytes(4, 'little')
bytes1 = p1.to_bytes(4, 'little')
# 拼接成8字节
plaintext_chunk = bytes0 + bytes1
# 尝试解码为ASCII字符串
try:
plaintext_str = plaintext_chunk.decode('utf-8')
print(f" 明文字符串: '{plaintext_str}'")
except UnicodeDecodeError:
print(f" 明文字节: {plaintext_chunk.hex()}")
plaintext_str = plaintext_chunk.decode('latin-1')
flag_parts.append(plaintext_str)
print()
# 拼接所有明文片段
final_flag = "".join(flag_parts)
print("=" * 60)
print("[+] 解密完成!")
print("=" * 60)
print(f"\nFlag: {final_flag}\n")
return final_flag
if __name__ == '__main__':
main()
6.3 运行解密脚本
执行脚本：
python3 decrypt_flag.py
输出结果：
============================================================
MimicWorld Flag 解密工具
============================================================
[+] 开始解密4组数据块...
[数据块 1/4]
加密值: R0=0xC1636AF0, R1=0x66011374
解密值: R0=0x67616C66, R1=0x3468537B
明文字符串: 'flag{Sh4'
[数据块 2/4]
加密值: R0=0x7C1868BD, R1=0xBE23BA8D
解密值: R0=0x5F773064, R1=0x545F6630
明文字符串: 'd0w_0f_T'
[数据块 3/4]
加密值: R0=0x9E9765E2, R1=0x16C7A9B0
解密值: R0=0x4D5F3368, R1=0x63316D31
明文字符串: 'h3_M1m1c'
[数据块 4/4]
加密值: R0=0x70DB4A7E, R1=0xBEBE3372
解密值: R0=0x6E314B5F, R1=0x7D212167
明文字符串: '_K1ng!!}'
============================================================
[+] 解密完成!
============================================================
Flag: flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}
七、解密正确性验证
7.1 为什么需要验证？
解密得到的flag可能不正确，原因包括：
- 解密算法有误
- 密文提取错误
- 参数设置不对
最可靠的验证方法是：将明文重新加密，检查是否得到相同的密文。
7.2 编写验证脚本
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Flag验证脚本
通过重新加密来验证解密结果的正确性
"""
def F(v, k):
"""TEA变种的F函数"""
r4 = ((v << 5) + 0x1337CAFE) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xDEADBEEF) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
def G(v, k):
"""TEA变种的G函数"""
r4 = ((v << 5) + 0x8BADF00D) & 0xFFFFFFFF
r5 = (v + k) & 0xFFFFFFFF
r6 = ((v >> 3) + 0xFEEDC0DE) & 0xFFFFFFFF
return (r4 ^ r5 ^ r6) & 0xFFFFFFFF
def encrypt_block(r0_plain, r1_plain):
"""
加密一个8字节数据块
参数:
r0_plain: 明文的R0值
r1_plain: 明文的R1值
返回:
(r0_encrypted, r1_encrypted): 加密后的R0和R1值
"""
DELTA = 0x7FC3951D
r0 = r0_plain
r1 = r1_plain
r2 = 0
# 32轮加密
for round_num in range(1, 33):
r2 = (r2 + DELTA) & 0xFFFFFFFF
r0 = (r0 + F(r1, r2)) & 0xFFFFFFFF
r1 = (r1 + G(r0, r2)) & 0xFFFFFFFF
return r0, r1
def main():
"""验证flag的正确性"""
print("=" * 60)
print("Flag正确性验证")
print("=" * 60)
print()
# 解密得到的flag
flag = "flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}"
# 题目中的密文（期望值）
expected_ciphertexts = [
(0xC1636AF0, 0x66011374),
(0x7C1868BD, 0xBE23BA8D),
(0x9E9765E2, 0x16C7A9B0),
(0x70DB4A7E, 0xBEBE3372),
]
print(f"测试Flag: {flag}")
print(f"Flag长度: {len(flag)} 字节\n")
# 转换为字节
flag_bytes = flag.encode('utf-8')
if len(flag_bytes) != 32:
print(f"[!] 错误: Flag长度应为32字节，实际{len(flag_bytes)}字节")
return False
print("[+] 开始验证...\n")
all_match = True
# 分4组验证
for i in range(4):
offset = i * 8
chunk = flag_bytes[offset:offset+8]
# 转换为两个32位整数（小端序）
r0 = int.from_bytes(chunk[0:4], 'little')
r1 = int.from_bytes(chunk[4:8], 'little')
print(f"[组 {i+1}/4]")
print(f" 明文: '{chunk.decode('utf-8')}'")
print(f" 明文值: R0=0x{r0:08X}, R1=0x{r1:08X}")
# 加密
c0, c1 = encrypt_block(r0, r1)
print(f" 加密结果: R0=0x{c0:08X}, R1=0x{c1:08X}")
print(f" 期望密文: R0=0x{expected_ciphertexts[i][0]:08X}, R1=0x{expected_ciphertexts[i][1]:08X}")
# 比较
if c0 == expected_ciphertexts[i][0] and c1 == expected_ciphertexts[i][1]:
print(f" [验证] 匹配成功!\n")
else:
print(f" [验证] 匹配失败!\n")
all_match = False
print("=" * 60)
if all_match:
print("[验证结果] 所有测试通过，Flag完全正确!")
print(f"\n正确的Flag: {flag}")
else:
print("[验证结果] 验证失败，Flag不正确!")
print("=" * 60)
return all_match
if __name__ == '__main__':
main()
7.3 验证结果
运行验证脚本：
python3 verify_flag.py
输出：
============================================================
Flag正确性验证
============================================================
测试Flag: flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}
Flag长度: 32 字节
[+] 开始验证...
[组 1/4]
明文: 'flag{Sh4'
明文值: R0=0x67616C66, R1=0x3468537B
加密结果: R0=0xC1636AF0, R1=0x66011374
期望密文: R0=0xC1636AF0, R1=0x66011374
[验证] 匹配成功!
[组 2/4]
明文: 'd0w_0f_T'
明文值: R0=0x5F773064, R1=0x545F6630
加密结果: R0=0x7C1868BD, R1=0xBE23BA8D
期望密文: R0=0x7C1868BD, R1=0xBE23BA8D
[验证] 匹配成功!
[组 3/4]
明文: 'h3_M1m1c'
明文值: R0=0x4D5F3368, R1=0x63316D31
加密结果: R0=0x9E9765E2, R1=0x16C7A9B0
期望密文: R0=0x9E9765E2, R1=0x16C7A9B0
[验证] 匹配成功!
[组 4/4]
明文: '_K1ng!!}'
明文值: R0=0x6E314B5F, R1=0x7D212167
加密结果: R0=0x70DB4A7E, R1=0xBEBE3372
期望密文: R0=0x70DB4A7E, R1=0xBEBE3372
[验证] 匹配成功!
============================================================
[验证结果] 所有测试通过，Flag完全正确!
正确的Flag: flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}
============================================================
验证通过！这证明我们的解密算法完全正确。
八、完整解题流程总结
8.1 技术路线图
MimicWorld.exe
|
v
[1] PE文件分析
|
+---> 定位.rdata节
+---> 提取VM字节码（21511字节）
|
v
[2] LCG解密
|
+---> 识别LCG算法
+---> 确定参数（seed=0xDEADBEEF）
+---> 生成密钥流并XOR解密
|
v
[3] VM反汇编
|
+---> 识别指令格式（7字节）
+---> 定义指令集（12种操作）
+---> 反汇编3072条指令
|
v
[4] 加密算法分析
|
+---> 识别TEA变种
+---> 提取常量和参数
+---> 理解加密流程
|
v
[5] 提取密文
|
+---> 定位CMP指令
+---> 提取4组校验值
|
v
[6] 编写解密算法
|
+---> 推导逆向算法
+---> 实现解密函数
+---> 解密4组数据
|
v
[7] 验证结果
|
+---> 重新加密明文
+---> 对比密文
+---> 确认正确性
|
v
flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}
8.2 关键技术点回顾
1. PE文件结构
- DOS头、PE头、节表的作用
- RVA到文件偏移的转换公式
- 如何手动解析二进制文件
2. LCG算法
- 线性同余生成器的数学原理
- 为什么常用于流加密
- XOR加密的对称性
3. 虚拟机保护
- VM保护的原理和目的
- 自定义指令集的设计
- 如何反汇编虚拟机代码
4. TEA加密算法
- Feistel网络结构
- 迭代加密的思想
- 如何逆向Feistel结构
5. 逆向工程思维
- 从整体到局部的分析方法
- 识别算法特征的技巧
- 验证结果的重要性
8.3 工具和脚本
解题过程中编写的脚本：
- extract_data.py – PE文件数据提取
- decrypt_and_disasm.py – LCG解密和VM反汇编
- decrypt_flag.py – TEA解密获取flag
- verify_flag.py – 加密验证flag正确性
所有脚本都是纯Python实现，无需额外依赖。
8.4 最终答案
flag{Sh4d0w_0f_Th3_M1m1c_K1ng!!}
九、学习建议与扩展
9.1 前置知识
要完成这类题目，需要掌握：
- 二进制文件格式
- PE、ELF等可执行文件格式
- 文件头、节表等结构
- 虚拟内存映射
- 密码学基础
- 对称加密（分组密码、流密码）
- 常见算法（DES、AES、TEA等）
- 加密模式（ECB、CBC等）
- 编程能力
- Python字节操作
- 位运算（AND、OR、XOR、移位）
- 大小端序处理
- 逆向工程
- IDA Pro、Ghidra等工具使用
- 汇编语言基础
- 控制流分析
9.2 练习建议
- 从简单开始
- 先做基础的XOR加密题
- 逐步过渡到复杂算法
- 理解原理
- 不要只记脚本模板
- 深入理解算法原理
- 动手实践
- 自己编写所有脚本
- 尝试优化和改进
- 建立知识库
- 整理常见算法特征
- 记录解题思路
9.3 相关题型
类似的CTF题目类型：
- VM保护变种
- 不同指令集设计
- 多层VM嵌套
- 动态生成指令
- 加密算法变种
- RC4、AES的修改版
- 自定义Feistel结构
- 混合多种算法
- 反调试技术
- 时间检测
- 调试器检测
- 代码混淆
9.4 深入研究
想要深入学习可以：
- 阅读源码
- VMProtect、Themida等商业保护
- LLVM Obfuscator等开源项目
- 研究论文
- 虚拟化保护相关论文
- 代码混淆技术研究
- 实践项目
- 实现简单的VM保护
- 编写自动化分析工具
十、总结
本题综合考查了PE文件分析、流加密解密、虚拟机逆向、分组密码分析等多个知识点，是一道优秀的综合性逆向题目。
通过完整的分析过程，我们：
- 掌握了PE文件的手动解析方法
- 理解了LCG算法在流加密中的应用
- 学会了虚拟机保护的分析思路
- 熟悉了TEA加密算法及其变种
- 掌握了逆向工程的验证方法
最重要的是，整个过程展示了逆向分析的完整思路：从文件格式分析开始，逐层剥离保护，最终破解核心算法。这种系统性的分析方法，是逆向工程的核心能力。
希望本文能帮助读者理解虚拟机保护和加密算法的逆向分析方法，在CTF比赛和实际工作中有所收获。
免责声明：
本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。
任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。
本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。
本文转载自：破镜安全 破镜安全《解析2025强网拟态决赛MimicWorld》