LitCTF2025 Reverse Engineering Writeup & 复现

目录

1. easy_rc4
2. FeatureExtraction
3. eazy_tea
4. pickle
5. Robbie Wanna Revenge

easy_rc4

知识点

• RC4加密算法原理
• 密钥流生成过程
• 加密/解密流程

解题步骤

1. 识别RC4特征：

   • 查找初始化S盒的代码
   • 寻找密钥调度算法(KSA)
   • 识别伪随机生成算法(PRGA)

2. 逆向分析：

   • 提取加密密钥
   • 分析加密数据流
   • 重建解密流程

3. 解密脚本：

def rc4_decrypt(ciphertext, key):
    # KSA阶段
    S = list(range(256))
    j = 0
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]
    
    # PRGA阶段
    i = j = 0
    plaintext = []
    for char in ciphertext:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        plaintext.append(char ^ S[(S[i] + S[j]) % 256])
    
    return bytes(plaintext)

FeatureExtraction

关键点

1. 特征提取方法：

   • 函数调用频率分析
   • API调用序列
   • 代码段特征码

2. 逆向技巧：

   • 使用IDA Pro的Function Calls视图
   • 分析导入表特征
   • 识别反调试技术

3. 解决方案：

   • 构建特征签名数据库
   • 实现动态特征提取
   • 使用模糊匹配算法

eazy_tea

TEA算法分析

1. 算法结构：

   • 64位数据块
   • 128位密钥
   • 32轮Feistel结构

2. 逆向要点：

void tea_decrypt(uint32_t v[2], uint32_t k[4]) {
    uint32_t v0 = v[0], v1 = v[1], sum = 0xC6EF3720, i;
    uint32_t delta = 0x9E3779B9;
    
    for(i=0; i<32; i++) {
        v1 -= ((v0<<4) + k[2]) ^ (v0 + sum) ^ ((v0>>5) + k[3]);
        v0 -= ((v1<<4) + k[0]) ^ (v1 + sum) ^ ((v1>>5) + k[1]);
        sum -= delta;
    }
    
    v[0] = v0; v[1] = v1;
}

3. 解题步骤：
   • 定位加密函数
   • 提取轮密钥
   • 实现解密函数

pickle

Python序列化分析

1. 风险点：

   • 任意代码执行漏洞
   • 对象注入攻击

2. 逆向方法：

import pickle
import pickletools

# 安全分析pickle数据
def analyze_pickle(pickle_data):
    pickletools.dis(pickle_data)
    
    # 安全加载
    safe_classes = {'allowed_class': AllowedClass}
    unpickler = pickle.Unpickler(io.BytesIO(pickle_data))
    unpickler.find_class = lambda module, name: safe_classes.get(name, None)
    return unpickler.load()

3. 防护措施：
   • 使用安全的替代方案(json)
   • 实现白名单机制
   • 签名验证pickle数据

Robbie Wanna Revenge

解法1：常规分析

1. 流程分析：

   • 反编译.NET程序集
   • 识别关键验证函数
   • 跟踪数据流

2. 关键代码：

// 反编译后的关键验证逻辑
bool ValidateInput(string input) {
    byte[] transformed = Encoding.UTF8.GetBytes(input);
    if(transformed.Length != 32) return false;
    
    for(int i=0; i<16; i++) {
        if((transformed[i] ^ transformed[i+16]) != target[i]) {
            return false;
        }
    }
    return true;
}

3. 破解脚本：

def solve():
    target = [0x12, 0x34, 0x56, ..., 0x78] # 从二进制提取的目标数组
    flag_part1 = b'LitCTF{' # 已知部分
    flag_part2 = bytes([flag_part1[i] ^ target[i] for i in range(7)])
    return flag_part1 + flag_part2 + b'}' 

高级解法：符号执行

import angr

proj = angr.Project("Robbie.exe", auto_load_libs=False)
state = proj.factory.entry_state()
simgr = proj.factory.simulation_manager(state)
simgr.explore(find=0x401234) # 成功验证的地址

if simgr.found:
    solution = simgr.found[0].posix.dumps(0)
    print("Flag:", solution.decode())

总结

1. 逆向工程方法论：

   • 静态分析与动态分析结合
   • 密码算法识别技巧
   • 反混淆技术

2. 工具链推荐：

   • IDA Pro/Ghidra/Binary Ninja
   • x64dbg/WinDbg
   • angr/Qiling框架

3. 进阶方向：

   • 自动化逆向脚本开发
   • 漏洞模式识别
   • 反反调试技术研究