第3章：逆向工程理论基础
3.1 逆向工程概述
3.1.1 逆向工程定义
逆向工程（Reverse Engineering）是一种通过分析现有系统或产品来理解其设计原理、工作机制和实现方法的技术过程。在软件领域，逆向工程主要指通过分析已编译的程序来理解其源代码逻辑、算法实现和系统架构。
3.1.2 逆向工程的分类
按分析层次分类：
pyramid
title 逆向工程分析层次
"源码级逆向" : 1
"字节码级逆向" : 10
"汇编级逆向" : 100
"二进制级逆向" : 1000
- 源码级逆向：直接分析源代码
- 字节码级逆向：分析中间代码（如Java字节码、.NET IL）
- 汇编级逆向：分析汇编指令
- 二进制级逆向：分析机器码
按分析方法分类：
| 分析方法 | 特点 | 优势 | 劣势 |
|---|---|---|---|
| 静态分析 | 不运行程序 | 全面、安全 | 难以处理动态特性 |
| 动态分析 | 运行时分析 | 直观、准确 | 覆盖率有限 |
| 混合分析 | 结合两种方法 | 互补优势 | 复杂度高 |
3.1.3 逆向工程的应用场景
合法应用场景：
mindmap
root((逆向工程应用))
安全研究
漏洞发现
恶意软件分析
安全评估
软件维护
遗留系统维护
Bug修复
功能增强
互操作性
协议分析
接口逆向
兼容性开发
学术研究
算法研究
系统分析
教学演示
示例：恶意软件分析流程
# 恶意软件分析的基本流程
class MalwareAnalysis:
def __init__(self, sample_path):
self.sample_path = sample_path
self.analysis_results = {}
def static_analysis(self):
"""静态分析阶段"""
results = {
'file_info': self.get_file_info(),
'strings': self.extract_strings(),
'imports': self.analyze_imports(),
'exports': self.analyze_exports(),
'sections': self.analyze_sections()
}
return results
def dynamic_analysis(self):
"""动态分析阶段"""
results = {
'network_activity': self.monitor_network(),
'file_operations': self.monitor_files(),
'registry_changes': self.monitor_registry(),
'process_behavior': self.monitor_processes()
}
return results
def behavioral_analysis(self):
"""行为分析阶段"""
return {
'malware_family': self.classify_malware(),
'attack_vectors': self.identify_attack_vectors(),
'persistence_mechanisms': self.analyze_persistence(),
'communication_protocols': self.analyze_c2()
}
3.2 汇编语言基础
3.2.1 汇编语言概述
汇编语言是逆向工程的基础，它是机器语言的符号化表示。理解汇编语言对于深入分析程序至关重要。
主要CPU架构对比：
| 架构 | 位数 | 寄存器数量 | 指令集特点 | 应用场景 |
|---|---|---|---|---|
| x86 | 32位 | 8个通用寄存器 | CISC复杂指令集 | PC、服务器 |
| x86-64 | 64位 | 16个通用寄存器 | 扩展x86 | 现代PC、服务器 |
| ARM | 32/64位 | 16个通用寄存器 | RISC精简指令集 | 移动设备、嵌入式 |
| MIPS | 32/64位 | 32个通用寄存器 | RISC指令集 | 嵌入式、路由器 |
3.2.2 ARM汇编基础
由于安卓设备主要使用ARM架构，我们重点学习ARM汇编：
ARM寄存器组织：
ARM指令格式：
; ARM指令的基本格式
; <opcode>{<cond>}{S} <Rd>, <Rn>, <operand2>
; 示例：条件执行
CMP R0, #10 ; 比较R0与立即数10
BEQ equal_label ; 如果相等则跳转
BGT greater_label ; 如果大于则跳转
BLT less_label ; 如果小于则跳转
equal_label:
MOV R1, #1 ; R1 = 1
B end_label ; 无条件跳转
greater_label:
MOV R1, #2 ; R1 = 2
B end_label
less_label:
MOV R1, #0 ; R1 = 0
end_label:
; 程序继续执行
常用ARM指令：
; 数据传输指令
MOV R0, R1 ; R0 = R1
MOV R0, #100 ; R0 = 100 (立即数)
LDR R0, [R1] ; R0 = *R1 (从内存加载)
STR R0, [R1] ; *R1 = R0 (存储到内存)
LDR R0, [R1, #4] ; R0 = *(R1 + 4) (带偏移加载)
; 算术运算指令
ADD R0, R1, R2 ; R0 = R1 + R2
SUB R0, R1, R2 ; R0 = R1 - R2
MUL R0, R1, R2 ; R0 = R1 * R2
RSB R0, R1, R2 ; R0 = R2 - R1 (反向减法)
; 逻辑运算指令
AND R0, R1, R2 ; R0 = R1 & R2
ORR R0, R1, R2 ; R0 = R1 | R2
EOR R0, R1, R2 ; R0 = R1 ^ R2 (异或)
BIC R0, R1, R2 ; R0 = R1 & (~R2) (位清除)
; 移位操作
LSL R0, R1, #2 ; R0 = R1 << 2 (逻辑左移)
LSR R0, R1, #2 ; R0 = R1 >> 2 (逻辑右移)
ASR R0, R1, #2 ; R0 = R1 >> 2 (算术右移)
ROR R0, R1, #2 ; R0 = R1 循环右移2位
; 比较和测试指令
CMP R0, R1 ; 比较R0和R1 (R0 - R1)
CMN R0, R1 ; 比较R0和-R1 (R0 + R1)
TST R0, R1 ; 测试 (R0 & R1)
TEQ R0, R1 ; 测试相等 (R0 ^ R1)
; 分支指令
B label ; 无条件跳转
BL function ; 调用函数 (保存返回地址到LR)
BX R0 ; 跳转到R0指向的地址
BLX R0 ; 调用R0指向的函数
3.2.3 函数调用约定
ARM AAPCS (ARM Architecture Procedure Call Standard)：
; 函数调用示例
; int add(int a, int b, int c, int d, int e)
; 参数传递：R0=a, R1=b, R2=c, R3=d, 栈传递e
; 返回值：R0
add_function:
; 函数序言 (Prologue)
PUSH {R4-R11, LR} ; 保存寄存器和返回地址
SUB SP, SP, #16 ; 为局部变量分配栈空间
; 获取第5个参数 (从栈中)
LDR R4, [SP, #(16+9*4)] ; e = *(SP + offset)
; 执行计算 a + b + c + d + e
ADD R0, R0, R1 ; R0 = a + b
ADD R0, R0, R2 ; R0 = a + b + c
ADD R0, R0, R3 ; R0 = a + b + c + d
ADD R0, R0, R4 ; R0 = a + b + c + d + e
; 函数尾声 (Epilogue)
ADD SP, SP, #16 ; 释放局部变量空间
POP {R4-R11, PC} ; 恢复寄存器并返回
; 调用示例
main:
; 准备参数
MOV R0, #1 ; a = 1
MOV R1, #2 ; b = 2
MOV R2, #3 ; c = 3
MOV R3, #4 ; d = 4
MOV R4, #5 ; e = 5
PUSH {R4} ; 第5个参数压栈
BL add_function ; 调用函数
ADD SP, SP, #4 ; 清理栈参数
; R0现在包含返回值15
3.2.4 ARM64 (AArch64) 基础
现代安卓设备多使用64位ARM架构：
; ARM64寄存器命名
; X0-X30: 64位通用寄存器
; W0-W30: 对应的32位寄存器 (X寄存器的低32位)
; SP: 栈指针
; PC: 程序计数器 (不能直接访问)
; ARM64指令示例
mov x0, #100 ; x0 = 100
mov w1, #50 ; w1 = 50 (32位操作)
ldr x2, [x1] ; x2 = *x1
str x0, [x1, #8] ; *(x1 + 8) = x0
; 算术运算
add x0, x1, x2 ; x0 = x1 + x2
sub x0, x1, x2 ; x0 = x1 - x2
mul x0, x1, x2 ; x0 = x1 * x2
; 条件分支
cmp x0, x1 ; 比较x0和x1
b.eq equal_label ; 相等时跳转
b.ne not_equal_label ; 不相等时跳转
b.gt greater_label ; 大于时跳转
; 函数调用 (ARM64 AAPCS)
; 参数：X0-X7, 返回值：X0
; 被调用者保存：X19-X28
; 调用者保存：X0-X18
function_example:
stp x29, x30, [sp, #-16]! ; 保存帧指针和链接寄存器
mov x29, sp ; 设置帧指针
; 函数体
add x0, x0, x1 ; 计算并返回
ldp x29, x30, [sp], #16 ; 恢复寄存器
ret ; 返回
3.3 程序分析理论
3.3.1 控制流分析
控制流分析是理解程序执行路径的基础：
控制流图（CFG）构建：
class BasicBlock:
"""基本块：没有分支的指令序列"""
def __init__(self, start_addr, end_addr):
self.start_addr = start_addr
self.end_addr = end_addr
self.instructions = []
self.predecessors = [] # 前驱基本块
self.successors = [] # 后继基本块
def add_instruction(self, instruction):
self.instructions.append(instruction)
def add_successor(self, block):
if block not in self.successors:
self.successors.append(block)
block.predecessors.append(self)
class ControlFlowGraph:
"""控制流图"""
def __init__(self):
self.blocks = []
self.entry_block = None
self.exit_blocks = []
def build_from_instructions(self, instructions):
"""从指令序列构建CFG"""
# 1. 识别基本块边界
leaders = self.find_leaders(instructions)
# 2. 创建基本块
self.create_basic_blocks(instructions, leaders)
# 3. 建立基本块之间的连接
self.connect_blocks()
def find_leaders(self, instructions):
"""找到基本块的起始指令（领导者）"""
leaders = set([0]) # 第一条指令总是领导者
for i, instr in enumerate(instructions):
# 分支指令的目标是领导者
if instr.is_branch():
target = instr.get_target()
if target is not None:
leaders.add(target)
# 分支指令的下一条指令也是领导者
if i + 1 < len(instructions):
leaders.add(i + 1)
return sorted(leaders)
def analyze_dominance(self):
"""支配关系分析"""
# 计算每个基本块的支配者
dominators = {}
for block in self.blocks:
dominators[block] = set(self.blocks)
# 迭代计算直到收敛
changed = True
while changed:
changed = False
for block in self.blocks:
if block == self.entry_block:
new_dom = {block}
else:
new_dom = set(self.blocks)
for pred in block.predecessors:
new_dom &= dominators[pred]
new_dom.add(block)
if new_dom != dominators[block]:
dominators[block] = new_dom
changed = True
return dominators
3.3.2 数据流分析
数据流分析追踪程序中数据的流动：
class DataFlowAnalysis:
"""数据流分析框架"""
def __init__(self, cfg):
self.cfg = cfg
self.in_sets = {} # 基本块入口的数据流信息
self.out_sets = {} # 基本块出口的数据流信息
def reaching_definitions(self):
"""到达定义分析"""
# 初始化
for block in self.cfg.blocks:
self.in_sets[block] = set()
self.out_sets[block] = set()
# 迭代计算直到收敛
changed = True
while changed:
changed = False
for block in self.cfg.blocks:
# IN[B] = ∪ OUT[P] for all predecessors P of B
new_in = set()
for pred in block.predecessors:
new_in |= self.out_sets[pred]
# OUT[B] = GEN[B] ∪ (IN[B] - KILL[B])
gen_set = self.compute_gen(block)
kill_set = self.compute_kill(block)
new_out = gen_set | (new_in - kill_set)
if new_in != self.in_sets[block] or new_out != self.out_sets[block]:
self.in_sets[block] = new_in
self.out_sets[block] = new_out
changed = True
def live_variable_analysis(self):
"""活跃变量分析（后向分析）"""
# 初始化
for block in self.cfg.blocks:
self.in_sets[block] = set()
self.out_sets[block] = set()
# 迭代计算直到收敛
changed = True
while changed:
changed = False
for block in reversed(self.cfg.blocks): # 后向分析
# OUT[B] = ∪ IN[S] for all successors S of B
new_out = set()
for succ in block.successors:
new_out |= self.in_sets[succ]
# IN[B] = USE[B] ∪ (OUT[B] - DEF[B])
use_set = self.compute_use(block)
def_set = self.compute_def(block)
new_in = use_set | (new_out - def_set)
if new_in != self.in_sets[block] or new_out != self.out_sets[block]:
self.in_sets[block] = new_in
self.out_sets[block] = new_out
changed = True
3.3.3 程序切片
程序切片技术用于提取影响特定变量的程序片段：
class ProgramSlicer:
"""程序切片器"""
def __init__(self, cfg, data_flow):
self.cfg = cfg
self.data_flow = data_flow
def backward_slice(self, variable, location):
"""后向切片：找到影响指定位置变量的所有语句"""
slice_set = set()
worklist = [(variable, location)]
visited = set()
while worklist:
var, loc = worklist.pop()
if (var, loc) in visited:
continue
visited.add((var, loc))
# 找到定义该变量的语句
definitions = self.find_definitions(var, loc)
for def_stmt in definitions:
slice_set.add(def_stmt)
# 递归处理定义语句中使用的变量
used_vars = self.get_used_variables(def_stmt)
for used_var in used_vars:
worklist.append((used_var, def_stmt.location))
return slice_set
def forward_slice(self, variable, location):
"""前向切片：找到受指定位置变量影响的所有语句"""
slice_set = set()
worklist = [(variable, location)]
visited = set()
while worklist:
var, loc = worklist.pop()
if (var, loc) in visited:
continue
visited.add((var, loc))
# 找到使用该变量的语句
uses = self.find_uses(var, loc)
for use_stmt in uses:
slice_set.add(use_stmt)
# 递归处理使用语句中定义的变量
defined_vars = self.get_defined_variables(use_stmt)
for defined_var in defined_vars:
worklist.append((defined_var, use_stmt.location))
return slice_set
3.4 逆向工程方法论
3.4.1 系统化逆向分析流程
详细分析流程：
class ReverseEngineeringWorkflow:
"""逆向工程工作流程"""
def __init__(self, target_file):
self.target = target_file
self.analysis_results = {}
self.hypotheses = []
def phase1_preparation(self):
"""第一阶段：准备工作"""
return {
'target_identification': self.identify_target(),
'information_gathering': self.gather_information(),
'environment_setup': self.setup_analysis_environment()
}
def phase2_analysis(self):
"""第二阶段：分析工作"""
return {
'preliminary_analysis': self.preliminary_analysis(),
'static_analysis': self.static_analysis(),
'dynamic_analysis': self.dynamic_analysis(),
'deep_analysis': self.deep_analysis()
}
def phase3_verification(self):
"""第三阶段：验证和文档"""
return {
'hypothesis_verification': self.verify_hypotheses(),
'documentation': self.generate_documentation(),
'reporting': self.generate_report()
}
def identify_target(self):
"""目标识别"""
return {
'file_type': self.detect_file_type(),
'architecture': self.detect_architecture(),
'compiler': self.detect_compiler(),
'packer': self.detect_packer(),
'obfuscation': self.detect_obfuscation()
}
def gather_information(self):
"""信息收集"""
return {
'metadata': self.extract_metadata(),
'strings': self.extract_strings(),
'imports': self.extract_imports(),
'exports': self.extract_exports(),
'resources': self.extract_resources()
}
def static_analysis(self):
"""静态分析"""
return {
'disassembly': self.disassemble_code(),
'control_flow': self.analyze_control_flow(),
'data_flow': self.analyze_data_flow(),
'function_analysis': self.analyze_functions(),
'cross_references': self.analyze_cross_references()
}
def dynamic_analysis(self):
"""动态分析"""
return {
'execution_trace': self.trace_execution(),
'api_monitoring': self.monitor_api_calls(),
'memory_analysis': self.analyze_memory(),
'network_analysis': self.analyze_network(),
'file_system_monitoring': self.monitor_file_system()
}
3.4.2 逆向分析策略
自顶向下策略：
class TopDownAnalysis:
"""自顶向下分析策略"""
def analyze(self, program):
# 1. 从程序入口点开始
entry_point = program.get_entry_point()
# 2. 分析主要功能模块
main_modules = self.identify_main_modules(entry_point)
# 3. 逐步深入到具体实现
for module in main_modules:
self.analyze_module_details(module)
def identify_main_modules(self, entry_point):
"""识别主要功能模块"""
# 通过调用图分析识别主要模块
call_graph = self.build_call_graph(entry_point)
return self.cluster_functions(call_graph)
自底向上策略：
class BottomUpAnalysis:
"""自底向上分析策略"""
def analyze(self, program):
# 1. 从基础组件开始分析
basic_functions = self.identify_basic_functions(program)
# 2. 理解基础功能
for func in basic_functions:
self.analyze_function_behavior(func)
# 3. 组合理解复杂功能
complex_functions = self.identify_complex_functions(program)
for func in complex_functions:
self.analyze_using_basic_understanding(func)
混合分析策略：
class HybridAnalysis:
"""混合分析策略"""
def analyze(self, program):
# 结合静态和动态分析
static_results = self.static_analysis(program)
dynamic_results = self.dynamic_analysis(program)
# 交叉验证和补充
return self.correlate_results(static_results, dynamic_results)
3.4.3 假设驱动分析
class HypothesisDrivenAnalysis:
"""假设驱动的分析方法"""
def __init__(self):
self.hypotheses = []
self.evidence = []
def generate_hypothesis(self, observation):
"""基于观察生成假设"""
hypothesis = {
'id': len(self.hypotheses),
'description': self.formulate_hypothesis(observation),
'confidence': 0.5,
'evidence_for': [],
'evidence_against': [],
'status': 'unverified'
}
self.hypotheses.append(hypothesis)
return hypothesis
def test_hypothesis(self, hypothesis_id):
"""测试假设"""
hypothesis = self.hypotheses[hypothesis_id]
# 设计实验来测试假设
experiments = self.design_experiments(hypothesis)
for experiment in experiments:
result = self.run_experiment(experiment)
if result.supports_hypothesis:
hypothesis['evidence_for'].append(result)
hypothesis['confidence'] += 0.1
else:
hypothesis['evidence_against'].append(result)
hypothesis['confidence'] -= 0.1
# 更新假设状态
if hypothesis['confidence'] > 0.8:
hypothesis['status'] = 'confirmed'
elif hypothesis['confidence'] < 0.2:
hypothesis['status'] = 'rejected'
return hypothesis
def refine_hypothesis(self, hypothesis_id, new_evidence):
"""基于新证据完善假设"""
hypothesis = self.hypotheses[hypothesis_id]
# 根据新证据调整假设
refined_hypothesis = self.adjust_hypothesis(hypothesis, new_evidence)
return refined_hypothesis
3.5 反汇编技术
3.5.1 线性扫描反汇编
class LinearSweepDisassembler:
"""线性扫描反汇编器"""
def __init__(self, binary_data, architecture):
self.data = binary_data
self.arch = architecture
self.instructions = []
def disassemble(self, start_address=0):
"""线性扫描反汇编"""
current_addr = start_address
while current_addr < len(self.data):
try:
# 解码指令
instruction = self.decode_instruction(current_addr)
self.instructions.append(instruction)
# 移动到下一条指令
current_addr += instruction.size
except InvalidInstructionError:
# 遇到无效指令，跳过一个字节
current_addr += 1
return self.instructions
def decode_instruction(self, address):
"""解码单条指令"""
# 根据架构解码指令
if self.arch == 'ARM':
return self.decode_arm_instruction(address)
elif self.arch == 'x86':
return self.decode_x86_instruction(address)
else:
raise UnsupportedArchitectureError(self.arch)
3.5.2 递归下降反汇编
class RecursiveDescentDisassembler:
"""递归下降反汇编器"""
def __init__(self, binary_data, architecture):
self.data = binary_data
self.arch = architecture
self.instructions = {}
self.visited = set()
self.to_visit = []
def disassemble(self, entry_points):
"""递归下降反汇编"""
# 添加入口点到待访问列表
self.to_visit.extend(entry_points)
while self.to_visit:
address = self.to_visit.pop()
if address in self.visited:
continue
self.disassemble_from_address(address)
return self.instructions
def disassemble_from_address(self, start_address):
"""从指定地址开始反汇编"""
current_addr = start_address
while current_addr not in self.visited and self.is_valid_address(current_addr):
self.visited.add(current_addr)
try:
instruction = self.decode_instruction(current_addr)
self.instructions[current_addr] = instruction
# 处理分支指令
if instruction.is_branch():
target = instruction.get_target()
if target and target not in self.visited:
self.to_visit.append(target)
# 如果是条件分支，继续处理下一条指令
if instruction.is_conditional():
current_addr += instruction.size
else:
break # 无条件跳转，停止当前路径
else:
current_addr += instruction.size
except InvalidInstructionError:
break
3.5.3 混合反汇编策略
class HybridDisassembler:
"""混合反汇编策略"""
def __init__(self, binary_data, architecture):
self.linear_disasm = LinearSweepDisassembler(binary_data, architecture)
self.recursive_disasm = RecursiveDescentDisassembler(binary_data, architecture)
self.data = binary_data
def disassemble(self, entry_points):
"""混合反汇编策略"""
# 1. 使用递归下降获得高质量的代码区域
recursive_results = self.recursive_disasm.disassemble(entry_points)
# 2. 使用线性扫描填补空隙
linear_results = self.linear_disasm.disassemble()
# 3. 合并结果，优先使用递归下降的结果
merged_results = self.merge_results(recursive_results, linear_results)
# 4. 后处理：识别数据区域
final_results = self.post_process(merged_results)
return final_results
def merge_results(self, recursive_results, linear_results):
"""合并反汇编结果"""
merged = recursive_results.copy()
for addr, instr in linear_results.items():
if addr not in merged:
# 验证指令的有效性
if self.validate_instruction(addr, instr):
merged[addr] = instr
return merged
def validate_instruction(self, address, instruction):
"""验证指令的有效性"""
# 检查指令是否与已知的代码区域重叠
# 检查指令是否符合架构规范
# 检查指令序列的合理性
return True # 简化实现
3.6 实践练习
练习1：ARM汇编分析
目标：分析以下ARM汇编代码的功能
function_mystery:
PUSH {R4-R6, LR}
MOV R4, R0 ; 保存第一个参数
MOV R5, R1 ; 保存第二个参数
MOV R6, #0 ; 初始化计数器
loop_start:
CMP R4, R5 ; 比较两个参数
BGE loop_end ; 如果R4 >= R5则退出循环
ADD R6, R6, R4 ; R6 += R4
ADD R4, R4, #1 ; R4++
B loop_start ; 继续循环
loop_end:
MOV R0, R6 ; 返回值 = R6
POP {R4-R6, PC} ; 恢复寄存器并返回
分析步骤：
-
函数签名分析：
- 参数：R0, R1
- 返回值：R0
- 使用寄存器：R4-R6
-
控制流分析：
-
功能推断：
- 这是一个求和函数
- 计算从R0到R1-1的整数和
- 等价的C代码：
int function_mystery(int start, int end) { int sum = 0; for (int i = start; i < end; i++) { sum += i; } return sum; }
练习2：控制流图构建
目标：为以下伪代码构建控制流图
int example_function(int x) {
int result = 0;
if (x > 10) { // Block 1
result = x * 2; // Block 2
} else {
result = x + 5; // Block 3
}
while (result < 100) { // Block 4
result += 10; // Block 5
}
return result; // Block 6
}
解答：
练习3：简单程序切片
目标：对以下程序进行后向切片，切片点为变量z在第8行
1: int x = 10;
2: int y = 20;
3: int z = 0;
4: if (x > 5) {
5: y = x + 3;
6: }
7: z = x + y;
8: printf("%d", z); // 切片点
解答：
后向切片结果包含以下语句：
- 第1行：
int x = 10;(影响x的值) - 第2行：
int y = 20;(影响y的初始值) - 第4行：
if (x > 5)(控制依赖) - 第5行：
y = x + 3;(重新定义y) - 第7行：
z = x + y;(直接定义z)
切片后的程序：
1: int x = 10;
2: int y = 20;
4: if (x > 5) {
5: y = x + 3;
6: }
7: z = x + y;
8: printf("%d", z);
3.7 常见问题与解答
Q1：静态分析和动态分析各有什么优缺点？
A1：
静态分析：
-
优点：
- 覆盖所有可能的执行路径
- 不需要运行程序，安全性高
- 可以发现潜在的但未执行的代码路径
- 分析结果可重现
-
缺点：
- 难以处理动态特性（多态、反射、动态加载）
- 可能产生误报（false positive）
- 对于混淆代码效果有限
- 无法获得运行时信息
动态分析：
-
优点：
- 获得真实的运行时行为
- 能够处理动态特性
- 结果准确，误报率低
- 可以观察实际的数据流
-
缺点：
- 只能覆盖执行的代码路径
- 需要构造合适的输入
- 可能触发恶意行为
- 结果依赖于执行环境
Q2：如何选择合适的反汇编策略？
A2：选择依据：
| 场景 | 推荐策略 | 原因 |
|---|---|---|
| 已知入口点的程序 | 递归下降 | 能够准确跟踪控制流 |
| 固件分析 | 线性扫描 | 代码和数据混合，需要全面扫描 |
| 恶意软件分析 | 混合策略 | 可能有反分析技术 |
| 库文件分析 | 递归下降 | 有明确的导出函数入口 |
| 加壳程序 | 动态分析+静态分析 | 需要先脱壳 |
Q3：程序分析中如何处理间接跳转？
A3：处理策略：
-
静态分析方法：
def analyze_indirect_jump(instruction, context): # 1. 值集分析 possible_targets = value_set_analysis(instruction.target_register) # 2. 跳转表识别 if is_jump_table_pattern(instruction): targets = extract_jump_table_targets(instruction) return targets # 3. 函数指针分析 if is_function_pointer(instruction.target_register): return analyze_function_pointer_targets(instruction) return possible_targets -
动态分析方法：
def trace_indirect_jumps(): # 运行时记录所有间接跳转的目标 indirect_targets = {} def on_indirect_jump(address, target): if address not in indirect_targets: indirect_targets[address] = set() indirect_targets[address].add(target) return indirect_targets -
混合方法：
- 使用动态分析收集可能的目标
- 用静态分析验证和补充
3.8 本章小结
本章深入介绍了逆向工程的理论基础：
- 逆向工程概述：定义、分类、应用场景
- 汇编语言基础：ARM/ARM64汇编、指令格式、调用约定
- 程序分析理论：控制流分析、数据流分析、程序切片
- 逆向工程方法论：系统化流程、分析策略、假设驱动方法
- 反汇编技术：线性扫描、递归下降、混合策略
这些理论知识为后续的实践操作提供了坚实的基础。理解了程序的内部结构和分析方法，才能在实际的逆向工程中游刃有余。
学习检查清单：
- 理解逆向工程的基本概念和分类
- 掌握ARM汇编的基本指令和调用约定
- 了解控制流图和数据流分析的原理
- 熟悉程序切片技术的应用
- 掌握系统化的逆向分析流程
- 理解不同反汇编策略的优缺点
- 能够分析简单的汇编代码功能
- 了解静态分析和动态分析的特点
下一章预告：
在下一章中，我们将学习如何搭建完整的安卓逆向分析环境，包括各种工具的安装配置、虚拟机环境搭建、以及分析环境的优化配置。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
