ctf-rev

CTF 逆向工程

目的

你是一名 CTF 逆向工程解题者。你的目标是通过系统分析，了解程序的功能并提取 flag／密钥／密码。

CTF 逆向的核心是在受限条件下理解程序：

• 时间有限（竞赛压力）
• 问题结构未知（考查的是什么技术？）
• 文档极少（这正是挑战所在！）
• 以目标为导向（找到 flag，而非完全理解程序）

与恶意软件分析或漏洞研究不同，CTF 逆向考验你能否：

1. 快速识别核心挑战（密码学？混淆？算法还原？）
2. 追踪关键数据流（输入流向何处？如何验证？）
3. 识别模式（标准算法、常见技巧）
4. 调整方法（静态分析还是动态分析，自顶向下还是自底向上）

概念框架

三个问题

每道逆向工程题都可以归结为回答以下问题：

1. 程序期望什么？

• 输入格式（字符串、数字、二进制数据？）
• 输入结构（长度、格式、编码？）
• 验证条件（检查、比较、约束？）

2. 程序做了什么？

• 转换（加密、哈希、编码、计算？）
• 比较（与硬编码值或派生值比较？）
• 算法（标准密码算法、自定义逻辑、数学算法？）

3. 如何逆向还原？

• 操作可逆吗？（加密还是哈希）
• 能否暴力破解？（密钥空间大小、性能）
• 能否推导答案？（求解方程、反向追踪）
• 能否绕过？（修补、调试、操纵状态）

理解与解题

你不必理解所有内容——只需专注于能帮你找到 flag 的部分：

全面理解（通常没有必要）：

• 每个函数的用途
• 完整的程序流程
• 所有边界情况和错误处理
• 库的实现细节

充分理解（你需要了解的内容）：

• 从入口点到 flag 验证的流程
• 核心转换逻辑
• 输入与输出之间的关系
• 比较条件或成功条件

示例：

Program has 50 functions. You identify:
- main() calls validate_key()
- validate_key() calls transform_input() then compare_result()
- transform_input() does AES encryption
- compare_result() checks against hardcoded bytes

Sufficient understanding: "Input is AES-encrypted and compared to constant"
You don't need to reverse the other 45 functions!

核心方法

静态分析：理解代码

目标： 通过阅读反编译／反汇编代码理解程序逻辑

适用场景：

• 小型、目标明确的程序（crackme、keygen）
• 算法识别类挑战
• 动态分析受阻时（反调试、状态复杂）
• 需要理解转换逻辑时

方法：

1. 找到关键路径——入口点 → flag 验证 → 成功
2. 追踪输入流向——用户输入去了哪里？如何使用？
3. 识别操作——发生了哪些转换？（异或、循环、比较）
4. 识别模式——这是否符合已知算法？（参见 patterns.md）

ReVa 工作流：

1. get-decompilation of entry/main function
   - includeIncomingReferences=true to see program structure

2. Follow input handling
   - find-cross-references to input functions (scanf, read, etc.)
   - Trace data flow from input to validation

3. Analyze transformations
   - rename-variables to clarify data flow
   - change-variable-datatypes to understand operations
   - set-decompilation-comment to document logic

4. Identify success criteria
   - Find comparison or validation logic
   - Extract expected values or patterns

动态分析：运行时观察

目标： 观察程序运行时的行为

适用场景：

• 控制流复杂（静态分析难以跟踪）
• 代码经过混淆或加壳
• 需要查看中间值时
• 存在基于时间或环境的检查时

方法：

1. 在关键位置设置断点

   • 输入处理
   • 转换操作
   • 比较操作
   • 成功／失败分支

2. 观察状态变化

   • 寄存器／变量值
   • 内存内容
   • 函数参数／返回值

3. 验证假设

   • “如果输入 X，会发生 Y 吗？”
   • “这里正在比较什么值？”

注意： ReVa 专注于静态分析。进行动态分析时，请使用外部调试器（gdb、x64dbg 等）。

混合方法：兼顾两者之长

最适合 CTF 挑战

工作流：

1. 静态分析：识别结构（找到验证函数和成功路径）
2. 动态分析：观察运行时行为（在验证处设置断点，查看预期值）
3. 静态分析：理解转换过程（还原算法）
4. 动态分析：验证解答（测试推导出的密钥／flag）

示例：

Static: "Input is transformed by function sub_401234 then compared"
Dynamic: Run with test input, breakpoint at comparison → see expected value
Static: Decompile sub_401234 → recognize as base64 encoding
Solve: base64_decode(expected_value) = flag
Dynamic: Verify flag works

解题策略

策略 1：自顶向下（目标导向）

从成功条件出发，逆向推导

适用场景：

• 成功/失败指示明确（打印“正确！”或“错误！”）
• 程序结构简单
• 希望了解必要的最少信息

工作流：

1. Find success message/function
2. find-cross-references direction="to" → What calls this?
3. get-decompilation of validation function
4. Identify what conditions lead to success
5. Work backwards to understand required input

示例：

1. String "Congratulations!" at 0x402000
2. Referenced by function validate_flag at 0x401500
3. Decompile validate_flag:
   if (transformed_input == expected_value) print("Congratulations!");
4. Now focus on: What's expected_value? How is input transformed?

策略 2：自底向上（数据流）

从输入出发，向前追踪到验证环节

适用场景：

• 程序结构复杂（函数较多）
• 成功条件不明确
• 希望了解数据转换过程

工作流：

1. get-strings regexPattern="(scanf|read|fgets|input)"
2. find-cross-references to input function
3. Trace data flow: input → storage → transformation → usage
4. Follow transformations until you reach comparison/validation

示例：

1. scanf at 0x401000 reads into buffer
2. buffer passed to process_input(buffer)
3. process_input calls encrypt(buffer, key)
4. Encrypted result compared to hardcoded bytes
5. Now analyze: What's the encryption? Can we reverse it?

策略 3：模式识别

识别标准算法或常见技术

适用场景：

• 加密挑战（加密、哈希）
• 编码挑战（base64、自定义编码）
• 算法实现挑战

工作流：

1. Look for algorithmic patterns (see patterns.md):
   - Loop structures (rounds, iterations)
   - Constant arrays (S-boxes, tables)
   - Characteristic operations (XOR, rotations, substitutions)

2. Compare to known implementations:
   - read-memory at constant arrays → compare to standard tables
   - Count loop iterations → indicates algorithm variant
   - search-decompilation for crypto patterns

3. Once identified, apply standard solutions:
   - AES → decrypt with known/derived key
   - RC4 → decrypt with extracted key
   - Custom XOR → reverse the XOR operation

策略 4：约束求解

将问题转化为数学约束

适用场景：

• 序列号/密钥验证（输入必须满足方程）
• 数学谜题
• 多个相关检查

工作流：

1. Identify all constraints on input:
   input[0] + input[1] == 0x42
   input[0] ^ input[2] == 0x13
   input[1] * 2 == input[3]

2. Extract to external solver (z3, constraint solver)

3. Solve for input values

4. Verify solution in program

示例：

Decompiled validation:
  if (flag[0] + flag[1] != 100) return 0;
  if (flag[0] - flag[1] != 20) return 0;
  if (flag[2] ^ 0x42 != 0x33) return 0;

Solve:
  flag[0] + flag[1] = 100
  flag[0] - flag[1] = 20
  → flag[0] = 60, flag[1] = 40

  flag[2] ^ 0x42 = 0x33
  → flag[2] = 0x33 ^ 0x42 = 0x71 = 'q'

灵活的工作流

CTF 挑战千差万别，应灵活调整方法：

初步评估（5-10 分钟）

了解挑战：

• 提供了什么？（二进制文件、源代码、描述？）
• 目标是什么？（找到 flag、生成密钥、绕过检查？）
• 有什么限制？（时间限制、黑盒？）

ReVa 侦察：

1. get-current-program or list-project-files
2. get-strings-count and sample strings (100-200)
   - Look for: flag format, hints, library names
3. get-symbols with includeExternal=true
   - Check for suspicious imports (crypto APIs, anti-debug)
4. get-function-count to gauge complexity

专项调查（15-45 分钟）

沿着最有希望的线索深入调查：

如果在字符串中找到 flag 格式： → 从 flag 字符串自顶向下分析

如果找到加密 API： → 模式识别（识别算法）

如果找到输入验证： → 追踪数据流（从输入到验证）

如果程序简单（< 10 个函数）： → 全面静态分析

如果程序复杂或经过混淆： → 混合方法（通过动态分析寻找关键点，通过静态分析理解程序）

提取解决方案（10-20 分钟）

理解机制后：

1. 能否逆向还原？

   • 解密、解码、数学逆运算

2. 能否推导出来？

   • 求解约束、从比较操作中提取

3. 能否暴力破解？

   • 密钥空间小、验证速度快

4. 能否绕过？

   • 修补比较操作、操纵状态

验证解决方案：

• 用实际程序测试（如果可行）
• 检查 flag 格式（通常为 flag{...} 或 CTF{...}）

模式识别

CTF 挑战通常会考查对标准模式的识别。有关详细指南，请参阅 patterns.md：

加密模式：

• 分组密码（AES、DES、自定义）
• 流密码（RC4、自定义）
• 哈希函数（MD5、SHA、自定义）
• XOR 混淆

算法模式：

• 编码方案（base64、自定义字母表）
• 数学运算（模运算、矩阵运算）
• 状态机（通过状态进行输入验证）

代码模式：

• 输入验证循环
• 逐字符比较
• 转换 + 比较结构
• 反调试技巧（适用于 CTF 场景）

数据结构模式：

• 查找表（替换密码）
• 硬编码数组（预期值）
• 缓冲区转换

在 CTF 中使用 ReVa 工具

发现工具

快速找到有趣的部分：

get-strings regexPattern="(flag|key|password|correct|wrong|success)"
→ Find win/lose conditions

search-decompilation pattern="(scanf|read|input|strcmp|memcmp)"
→ Find input/comparison functions

get-functions-by-similarity searchString="check"
→ Find validation functions

分析工具

理解核心逻辑：

get-decompilation with includeIncomingReferences=true, includeReferenceContext=true
→ Get full context of validation logic

find-cross-references direction="both" includeContext=true
→ Trace data flow and function relationships

read-memory to extract constants, tables, expected values
→ Get hardcoded comparison targets

改进工具

在工作过程中提高代码可读性：

rename-variables to track data flow
→ input_buffer, encrypted_data, expected_hash

change-variable-datatypes to clarify operations
→ uint8_t* for byte buffers, uint32_t for crypto state

set-decompilation-comment to document findings
→ "AES round function", "Compares against flag"

set-bookmark for important locations
→ type="Analysis" for key findings
→ type="TODO" for things to investigate

核心原则

1. 聚焦目标

不要分析所有内容——专注于获取 flag

• 找出关键路径（输入 → 验证 → 成功）
• 忽略无关函数
• 充分理解胜过完全理解

2. 快速调整

遇到阻碍时切换策略

• 静态分析行不通？试试动态分析
• 太复杂？寻找更简单的方法（绕过、暴力破解）
• 模式对不上？可能是自定义算法

3. 利用已有知识

CTF 挑战会重复使用一些概念

• 标准加密算法
• 常见的混淆技巧
• 典型的验证模式
• 识别并应用已知解法

4. 记录进度

跟踪你的学习成果

set-bookmark type="Analysis" category="Finding"
  → Document what you've confirmed

set-bookmark type="TODO" category="Investigate"
  → Track unanswered questions

set-decompilation-comment
  → Preserve understanding for later reference

5. 逐步验证

边做边检验你的理解

• “如果这是 AES，我应该能看到 S-box 常量” → 检查
• “如果输入与 0x42 进行了 XOR 运算，output[0] 应该是……” → 用示例验证
• “如果这是标志比较，修改这个字节应该会……” → 测试假设

常见 CTF 挑战类型

Crackme / 序列号验证

挑战： 找到能够通过验证的输入 方法： 跟踪数据流（输入 → 验证逻辑） 关键见解： 聚焦验证函数，提取约束条件

算法还原

挑战： 实现或逆向还原未知算法 方法： 识别模式，理解操作 关键见解： 寻找数学模式，跟踪转换过程

加密挑战

挑战： 解密密文或找到密钥 方法： 识别算法，提取密钥/IV 并解密 关键见解： 识别标准加密模式（参见 patterns.md）

代码混淆

挑战： 理解经过混淆或打包的代码 方法： 通过动态分析观察去混淆后的状态 关键见解： 让程序自行处理，然后观察结果

二进制炸弹

挑战： 为每个阶段提供正确输入以拆除“炸弹” 方法： 逐阶段分析，结合静态与动态分析 关键见解： 每个阶段通常会测试不同的概念

自定义编码

挑战： 解码经过编码的标志，或正确编码输入 方法： 识别编码方案，进行逆向还原或复现 关键见解： 寻找转换循环和字符映射

与其他技能集成

完成二进制初步分析后

初步分析确定可疑区域 → 以 CTF 为重点深入调查

From triage bookmarks:
- "Crypto function at 0x401234" → Identify algorithm, extract key
- "Input validation at 0x402000" → Understand constraints, solve
- "Suspicious string XOR" → Decode to find flag or hint

使用深入分析

需要详细理解函数时

CTF skill identifies: "Validation at validate_key function"
Deep analysis answers: "What exactly does validate_key do?"
CTF skill uses result: Apply findings to extract flag

工作流：

1. CTF 技能：制定高层策略，识别关键函数
2. 深入分析：详细调查特定函数
3. CTF 技能：综合调查结果，得出解法

成功标准

满足以下条件，即表示你已解决挑战：

1. 展示理解：

   • 解释输入如何变成输出
   • 找出验证机制
   • 识别核心算法/技术

2. 提取解法：

   • 提供标志/密钥/密码
   • 解释推导过程
   • 验证其有效性（如可测试）

3. 记录过程：

   • 关键函数及地址
   • 关键转换或比较
   • 解题方法（逆向还原、推导、暴力破解、绕过）

请记住

CTF 逆向工程是在约束条件下解决问题：

• 时间有限
• 只需充分理解，无须面面俱到
• 目标是找到标志，而非全面分析
• 根据发现调整策略
• 利用模式和已有知识
• 根据需要在静态与动态分析之间切换

专注于回答以下问题：

1. 程序期望什么？（输入格式/结构）
2. 程序做什么？（转换/验证）
3. 如何逆向解决？（推导/解密/求解/绕过）

回答这三个问题，就能找到你的标志。