从CTF到实战:无导出SO函数Hook的深度探索与高阶技巧
在移动安全研究的道路上,我们常常会遇到一个令人头疼的难题:那些核心逻辑被精心隐藏在SO库中,且函数名在导出表中消失得无影无踪。传统的符号Hook方法在此刻完全失效,仿佛面对一堵密不透风的墙。无论是CTF赛题中刻意设计的混淆,还是金融、社交类APP为保护核心算法而施加的加固,无导出函数的Hook都构成了逆向工程中一道必须跨越的鸿沟。
这篇文章将带你超越基础的Module.findExportByName,深入探索三种定位并Hook无导出SO函数的特殊方法。我们不会停留在理论层面,而是结合真实的CTF题目和商业APP案例,拆解每一步操作背后的原理与细节。无论你是想在CTF比赛中快速得分的安全爱好者,还是需要分析加固应用的安全研究员,这些技巧都将成为你工具箱中的利器。
1. 理解无导出函数的本质:为何常规方法失效
在开始技术探索之前,我们首先要明白一个基本问题:为什么有些SO函数在导出表中找不到? 这并非魔法,而是开发者有意为之的保护策略。
1.1 无导出函数的实现机制
在C/C++开发中,有几种常见方式可以隐藏函数导出:
使用__attribute__((visibility("hidden")))编译属性
// 这个函数不会出现在导出表中
__attribute__((visibility("hidden")))
void secret_algorithm(const char* input, char* output) {
// 核心加密逻辑
// ...
}
通过静态链接库内部函数
// 在静态库中编译,外部不可见
static void internal_processing(void* data) {
// 内部处理逻辑
}
动态注册JNI函数
// Java层声明
public native String nativeCalculate(String input);
// Native层动态注册
static JNINativeMethod methods[] = {
{"nativeCalculate", "(Ljava/lang/String;)Ljava/lang/String;", (void*)calculate_impl}
};
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
// 动态注册而非静态导出
env->RegisterNatives(clazz, methods, sizeof(methods)/sizeof(methods[0]));
return JNI_VERSION_1_6;
}
注意:动态注册是商业APP中最常见的隐藏手段。函数地址在运行时通过
RegisterNatives绑定,IDA的导出表中完全看不到这些函数名,只能看到JNI_OnLoad。
1.2 加固技术的干扰
现代加固方案会进一步加剧这个问题:
| 加固技术 | 对SO函数的影响 | 检测难度 |
|---|---|---|
| 代码混淆 | 函数逻辑被拆分、插入垃圾指令 | ★★★☆☆ |
| 控制流平坦化 | 函数执行流程被重构 | ★★★★☆ |
| 虚拟化保护 | 代码被转换为自定义字节码 | ★★★★★ |
| 完整性校验 | Hook检测和反调试 | ★★★★☆ |
面对这些保护,单纯依赖导出表就像在黑夜中寻找没有标记的门。我们需要更聪明的方法。
2. 方法一:字符串引用定位法——最直观的切入点
字符串是代码中难以完全隐藏的线索。即使函数名被抹去,函数内部使用的字符串常量仍然会留在.rodata段中。这为我们提供了第一个突破口。
2.1 原理与实现步骤
字符串定位法的核心思想是:通过函数内部引用的唯一字符串,反向定位到使用该字符串的函数。
操作流程如下:
-
静态分析寻找特征字符串
- 使用IDA Pro或Ghidra打开目标SO文件
- 查看Strings窗口,寻找可能的特征字符串
- 重点关注错误信息、日志标签、算法标识等
-
确定字符串在内存中的地址
// 查找字符串在内存中的位置 const targetString = "MD5_Transform"; const stringAddress = Module.findBaseAddress("libtarget.so") .add(Module.getExportByName("libtarget.so", "strlen")); // 示例,实际需计算偏移 // 或者直接搜索整个模块 Memory.scan(Module.findBaseAddress("libtarget.so"), Module.getSize("libtarget.so"), targetString, { onMatch: function(address, size) { console.log(`找到字符串 "${targetString}" 在地址: ${address}`); }, onComplete: function() { console.log("扫描完成"); } }); -
查找引用该字符串的代码位置
// 查找所有引用该字符串的指令 function findXrefToString(stringAddr) { const results = []; const base = Module.findBaseAddress("libtarget.so"); const size = Module.getSize("libtarget.so"); // 搜索LDR指令(ARM架构) // LDR指令模式: xx xx xx xx (32位指令) // 我们需要查找加载stringAddr的LDR指令 const pattern = "?? ?? ?? ??"; Memory.scan(base, size, pattern, { onMatch: function(address, size) { // 解析指令,检查是否加载目标地址 const instruction = Memory.readU32(address); // 简化检查:实际需要根据ARM指令编码解析 // 这里仅示意 console.log(`潜在引用指令在: ${address}`); results.push(address); }, onComplete: function() { console.log(`找到 ${results.length} 个潜在引用`); } }); return results; }
2.2 实战案例:CTF中的字符串线索
在某次CTF比赛中,我们遇到一个Android逆向题,关键验证函数被隐藏。通过静态分析,在IDA的Strings窗口发现一个可疑字符串:
"Verification_Failed_Check_Your_Input"
在Hex窗口查看该字符串的引用:
.rodata:0000A124 56 65 72 69 66 69 63 61 74 69 6F 6E 5F 46 61 69 Verification_Fai
.rodata:0000A134 6C 65 64 5F 43 68 65 63 6B 5F 59 6F 75 72 5F 49 led_Check_Your_I
.rodata:0000A144 6E 70 75 74 00 nput.
使用IDA的交叉引用功能(快捷键X),发现只有一处代码引用:
.text:00007A84 LDR R1, =(aVerificationFa - 0x7A90)
.text:00007A88 ADD R1, PC, R1 ; "Verification_Failed_Check_Your_Input"
由此我们定位到函数起始于0x7A84附近。通过分析上下文,确认这是验证失败时的提示信息,而验证逻辑就在这个函数中。
Frida Hook脚本实现:
Java.perform(function() {
const libName = "libchallenge.so";
const baseAddr = Module.findBaseAddress(libName);
if (!baseAddr) {
console.error(`模块 ${libName} 未加载`);
return;
}
// 通过字符串定位的函数偏移
const targetOffset = 0x7A84;
const targetAddr = baseAddr.add(targetOffset);
console.log(`目标函数地址: ${targetAddr}`);
Interceptor.attach(targetAddr, {
onEnter: function(args) {
console.log(`[+] 进入验证函数`);
// 打印第一个参数(假设是输入字符串)
const inputPtr = args[0];
if (!inputPtr.isNull()) {
const input = inputPtr.readUtf8String();
console.log(`输入: ${input}`);
}
// ARM架构下,R0是第一个参数,R1是第二个
// 这里我们也可以直接读取寄存器
console.log(`R0 (arg1): ${this.context.r0}`);
console.log(`R1 (arg2): ${this.context.r1}`);
},
onLeave: function(retval) {
console.log(`[+] 函数返回: ${retval}`);
// 通常验证函数返回布尔值或状态码
const success = retval.toInt32() !== 0;
console.log(`验证结果: ${success ? "成功" : "失败"}`);
}
});
});
2.3 优缺点分析
优点:
- 直观易懂,不需要深入理解算法逻辑
- 字符串在.rodata段,不会被代码混淆影响
- 适用于有明确错误提示或日志输出的函数
局限性:
- 如果函数内部没有字符串引用,此方法失效
- 字符串可能被加密或混淆
- 多个函数可能引用同一个字符串,需要进一步筛选
3. 方法二:调用栈回溯法——动态追踪执行路径
当字符串线索不可得时,我们可以换个思路:从已知的入口点出发,追踪执行路径,找到目标函数。这种方法特别适用于动态注册的JNI函数。
3.1 动态注册JNI的Hook策略
大多数Android应用使用RegisterNatives动态注册JNI函数。虽然这些函数不在导出表中,但注册过程本身是可以Hook的。
Hook RegisterNatives的基本原理:
// 查找libart.so中的RegisterNatives函数
function hookRegisterNatives() {
// 不同Android版本可能在不同模块中
const modules = ['libart.so', 'libartd.so', 'libnativehelper.so'];
let registerNativesAddr = null;
for (const moduleName of modules) {
const symbols = Module.enumerateSymbolsSync(moduleName);
for (const symbol of symbols) {
if (symbol.name.indexOf('RegisterNatives') !== -1 &&
symbol.name.indexOf('CheckJNI') === -1) {
console.log(`找到RegisterNatives: ${symbol.name} @ ${symbol.address}`);
registerNativesAddr = symbol.address;
break;
}
}
if (registerNativesAddr) break;
}
if (!registerNativesAddr) {
console.error("未找到RegisterNatives函数");
return;
}
Interceptor.attach(registerNativesAddr, {
onEnter: function(args) {
// JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods
const env = args[0];
const javaClass = args[1];
const methodsPtr = args[2];
const methodCount = args[3].toInt32();
console.log(`\n[RegisterNatives] 注册 ${methodCount} 个方法`);
// 获取Java类名
const className = getClassName(env, javaClass);
console.log(`类名: ${className}`);
// 遍历所有注册的方法
for (let i = 0; i < methodCount; i++) {
const methodEntry = methodsPtr.add(i * Process.pointerSize * 3);
const namePtr = Memory.readPointer(methodEntry);
const sigPtr = Memory.readPointer(methodEntry.add(Process.pointerSize));
const fnPtr = Memory.readPointer(methodEntry.add(Process.pointerSize * 2));
const name = Memory.readCString(namePtr);
const signature = Memory.readCString(sigPtr);
console.log(` [${i}] ${name}${signature} -> ${fnPtr}`);
// 记录函数地址供后续Hook使用
registerMethodHook(className, name, signature, fnPtr);
}
}
});
}
3.2 自动化Hook所有动态注册函数
手动记录每个函数地址很繁琐,我们可以编写自动化脚本:
#!/usr/bin/env python3
# auto_hook_jni.py - 自动Hook所有动态注册的JNI函数
import frida
import re
import json
from datetime import datetime
class JNIHookAutomator:
def __init__(self, package_name):
self.package_name = package_name
self.device = frida.get_usb_device()
self.session = None
self.hooked_methods = []
def on_message(self, message, data):
"""处理Frida消息"""
if message['type'] == 'send':
payload = message['payload']
if payload.get('type') == 'jni_registration':
self.process_jni_registration(payload['data'])
elif payload.get('type') == 'jni_call':
self.log_jni_call(payload['data'])
def process_jni_registration(self, registration_data):
"""处理JNI注册信息"""
class_name = registration_data['class']
method_name = registration_data['method']
signature = registration_data['signature']
address = registration_data['address']
module = registration_data.get('module', 'unknown')
offset = registration_data.get('offset', '0x0')
print(f"[+] 发现JNI注册: {class_name}.{method_name}{signature}")
print(f" 地址: {address}, 模块: {module}, 偏移: {offset}")
# 生成Hook脚本
hook_script = self.generate_hook_script(
class_name, method_name, signature, address, module, offset
)
# 注入Hook脚本
self.inject_hook_script(hook_script)
# 保存记录
self.hooked_methods.append({
'class': class_name,
'method': method_name,
'signature': signature,
'address': address,
'module': module,
'offset': offset,
'timestamp': datetime.now().isoformat()
})
def generate_hook_script(self, class_name, method_name, signature, address, module, offset):
"""为特定JNI方法生成Hook脚本"""
# 解析方法签名,确定参数类型
param_types = self.parse_jni_signature(signature)
script = f"""
Java.perform(function() {
{
const targetAddr = ptr("{address}");
console.log(`[+] Hook JNI方法: {class_name}.{method_name}`);
console.log(` 签名: {signature}`);
console.log(` 地址: ${
{targetAddr}}`);
Interceptor.attach(targetAddr, {
{
onEnter: function(args) {
{
this.callId = Date.now() + Math.random();
this.methodName = "{class_name}.{method_name}";
this.startTime = Date.now();
console.log(`[Call ${
{this.callId}}] 进入 ${
{this.methodName}}`);
console.log(` 模块: {module}, 偏移: {offset}`);
// 打印参数(JNIEnv*和jobject/jclass之后开始)
let argIndex = 2; // 跳过JNIEnv*和jobject/jclass
"""
# 根据参数类型生成打印代码
for i, param_type in enumerate
406



被折叠的 条评论
为什么被折叠?



