NewStarCTF2025-WEEK3：逆向工程实战——从魔改UPX到RC4与SM4的密码学挑战

1. 逆向工程实战：从魔改UPX到密码学挑战

在CTF逆向赛题中，加密算法与混淆技术的组合往往是最具挑战性的部分。本次NewStarCTF2025-WEEK3的题目就融合了魔改UPX壳、自定义轮加密、RC4变种以及SM4国密算法，形成了一道综合性极强的逆向工程题目。我们将从静态分析到动态调试，逐步拆解这道题目的各个技术要点。

逆向工程的核心在于理解程序的运行逻辑和数据流。对于这道题目，我们需要重点关注以下几个关键点：

• 魔改UPX壳的特征识别与脱壳技巧
• 自定义加密算法的逆向分析方法
• RC4变种算法的识别与解密
• SM4国密算法的实现特点

2. 魔改UPX壳的处理技巧

2.1 识别魔改UPX特征

标准的UPX壳有固定的特征标记，通常位于PE文件的特定位置。使用010 Editor等工具查看文件时，如果发现这些标记被修改，很可能遇到了魔改UPX壳。常见的修改方式包括：

• 修改UPX!标记为其他字符串
• 改变压缩算法标识位
• 修改解压缩代码段的入口点

识别魔改UPX的关键在于寻找解压缩代码的特征指令序列。即使标记被修改，解压逻辑的核心指令通常保持不变。

2.2 手动修复UPX标记

当遇到魔改UPX壳时，可以尝试以下步骤进行修复：

1. 使用PE工具查看文件结构，定位可能的压缩段
2. 搜索UPX标准解压代码的特征字节序列
3. 比较标准UPX与魔改版本的差异
4. 手动修复关键标记位

例如，可以使用以下Python代码片段检查UPX标记：

with open('target.exe', 'rb') as f: data = f.read() if b'UPX!' in data: print("标准UPX壳") else: print("可能是魔改UPX壳")

2.3 动态脱壳技巧

对于难以静态分析的魔改UPX壳，动态调试是最有效的方法：

1. 使用x64dbg或OllyDbg加载程序
2. 在可能的解压循环处设置断点
3. 跟踪内存写入操作，定位原始代码段
4. 在OEP(原始入口点)处dump内存

动态脱壳时需要注意反调试技巧，常见的应对方法包括：

• 使用ScyllaHide等插件隐藏调试器
• 修改关键跳转绕过反调试检查
• 在适当时机附加进程

3. 自定义轮加密算法分析

3.1 识别加密函数特征

在脱壳后的程序中，加密函数通常具有以下特征：

• 大量的位操作（XOR、移位、加减）
• 固定长度的密钥扩展
• 循环结构（特别是固定次数的循环）
• 内存中的数据对比操作

通过IDA的交叉引用分析，可以快速定位到关键的加密函数。例如，搜索"encrypt"、"decrypt"等字符串引用。

3.2 逆向自定义轮函数

题目中的自定义轮函数RoundFunc采用了多层位运算：

def RoundFunc(a1): a1 &= 0xffffffff v = (a1 + 1071031968) & 0xffffffff v ^= 0xFD714A3E v = (v + 1945724502) & 0xffffffff v ^= 0x1756F5FD v = (v - 1917457407) & 0xffffffff return v

逆向这类函数的关键是：

1. 记录每个步骤的输入输出
2. 分析位运算的可逆性
3. 构建逆向计算路径

对应的逆函数InvRoundFunc可以这样实现：

def InvRoundFunc(v): v &= 0xffffffff v = (v + 1917457407) & 0xffffffff v ^= 0x1756F5FD v = (v - 1945724502) & 0xffffffff v ^= 0xFD714A3E v = (v - 1071031968) & 0xffffffff return v

3.3 CBC模式逆向分析

题目采用了类似CBC的模式进行加密，逆向时需要：

1. 识别初始向量(IV)的使用方式
2. 跟踪每个加密块之间的依赖关系
3. 按相反顺序应用解密算法

解密过程的关键代码段：

# 步骤1: 将密文拆分为多个32位字 Count = len(target_bytes)//4 v12_final = [struct.unpack_from('<I', target_bytes, 4*i)[0] for i in range(Count)] # 步骤2: 逆向CBC模式 v14 = (Count + 2)//3 v12_pre = [0]*Count for jj in range(v14): for kk in range(3): v11 = 3*jj + kk if v11 >= Count: break if jj == 0: pre = v12_final[v11] ^ iv[kk] else: pre = v12_final[v11] ^ v12_final[v11 - 3] v12_pre[v11] = pre & 0xffffffff

4. RC4变种算法解析

4.1 标准RC4与变种区别

标准RC4算法包含两个阶段：

1. KSA(密钥调度算法)：初始化S盒
2. PRGA(伪随机生成算法)：生成密钥流

题目中的RC4变种主要修改了PRGA阶段：

def rc4_decrypt_mod(cipher_bytes, S_box): data = list(cipher_bytes) S = list(S_box) # 变种步骤1: 去除额外的"加i"操作 for i in range(len(data)): data[i] = (data[i] - i) & 0xFF # 变种步骤2: 修改的PRGA i = j = 0 for k in range(len(data)): i = (i + 1) % 256 j = (j + S[i]) % 256 S[i], S[j] = S[j], S[i] data[k] ^= S[(S[i] + S[j]) % 256] return bytes(data)

4.2 逆向RC4变种

逆向这类变种算法的关键是：

1. 识别S盒初始化方式
2. 分析PRGA阶段的修改点
3. 构建逆向密钥流

对于题目中的"加i"变种，解密时需要先减去索引值：

# 解密示例 cipher_hex = [0x50, 0x59, 0xA2, 0x94, 0x2E, 0x8E, 0x5C, 0x95, 0x79, 0x16, 0xE5, 0x36] cipher_bytes = bytes(cipher_hex) plaintext = rc4_decrypt_mod(cipher_bytes, s) print("解密结果:", plaintext.decode(errors="ignore"))

5. SM4国密算法实战

5.1 SM4算法基础

SM4是我国商用密码标准，属于分组加密算法，主要特点：

• 分组长度128位
• 密钥长度128位
• 32轮非线性迭代结构
• 使用S盒和线性变换

算法流程分为：

1. 密钥扩展
2. 32轮加密迭代
3. 反序输出

5.2 逆向SM4实现

题目中的SM4实现有几个关键修改点：

1. 使用固定密钥MK = [1,0,0,0,1,0,0,0,4,0,0,0,5,0,0,0]
2. 修改了轮函数中的线性变换
3. 输出采用反序存储

解密时需要特别注意：

def sm4_decrypt(ciphertext, mk): # 密钥扩展 rk = key_expansion(mk) # 密文反序 ciphertext = ciphertext[::-1] # 32轮解密 plaintext = ciphertext for i in range(32): plaintext = round_function(plaintext, rk[31-i]) return plaintext

5.3 识别SM4特征

在逆向过程中，可以通过以下特征识别SM4：

1. 固定的S盒（256字节）
2. 32轮的加密结构
3. 特定的线性变换（循环移位和异或）
4. 128位的分组处理

使用工具如signsrch可以快速定位SM4的S盒：

signsrch target.bin | grep -i "SM4"

6. 综合解题思路

完整的解题流程如下：

1. 识别并脱去魔改UPX壳
2. 分析主函数逻辑，定位加密调用
3. 逆向自定义轮加密算法
4. 解密RC4变种部分
5. 处理SM4加密段
6. 组合各部分结果获取flag

关键的解密脚本框架：

# 处理魔改UPX unpacked = upx_unpack(target) # 解密自定义轮加密 round_decrypted = inv_round_decrypt(unpacked) # 解密RC4变种 rc4_decrypted = rc4_mod_decrypt(round_decrypted) # 解密SM4 sm4_decrypted = sm4_decrypt(rc4_decrypted, MK) # 验证结果 if check_flag(sm4_decrypted): print("Flag found:", sm4_decrypted)

在实际比赛中，可能需要多次调试和验证每个步骤的输出。建议使用中间结果校验点，确保每一步的解密都正确无误。