-
-
[原创]尝试着实现了一个 ART Hook
-
发表于: 2019-1-27 21:09
-
首先要感谢 epic 和 yahfa 这两个开源项目，看完确实有不少收获。
Github: https://github.com/ganyao114/SandHook
CSDN: https://blog.csdn.net/ganyao939543405/article/details/86661040
关于 Hook，一直是比较小众的需求。本人公司有在做 Android Sandbox(类似 VA)，算是比较依赖 Hook 的产品，好在 Android Framework 大量使用了代理模式。所以也不用费劲在VM层作文章了，直接用动态代理即可。
然而，VM 层的 Java Hook 还是有些需求的，除了测试时候的性能监控，AOP 等之外。大多还是用在了黑灰产，Android Sandbox + ART Hook = 免越狱的 Xposed。
正好拜读了 epic 和 yahfa 的源码，也是有所收获并且尝试着写了这个框架。
5.0 - 9.0
基本除了抽象方法都能 Hook，抽象方法实在无能为力：大多数情况不走 ArtMethod，即便替换 vtable，依然会遗漏很多实现。
最主要的是 ART 很容易确定了接口的实现类就根本不查 vtable，直接调实现方法去了。。。。所以还是老老实实 hook 实现方法吧
依赖：
写 Hook 项：
Hook 项由 Hook 类， Hook 方法，Backup 方法组成，如果不需要掉用原方法则不需要写 Backup 方法。
如果 OS <= 5.1 ，backup 方法建议调用自己(或加 try catch)，否则会被内联进 hook 方法，导致无法调用原方法。当然你也可以使用 invoke 调用原方法。
简单的来说就是 inline hook。
将目标方法的前(arm32-2/arm64-4)行代码拷贝出来，换上跳转代码跳到一个汇编写的二级跳板，二级跳板再确定当前方法需要 Hook 之后，跳转到 Hook 方法。
除此之外，考虑到 N 以上方法有可能是解释执行，手动调用 JIT 有可能编译失败(很少见)，也保留了 ArtMethod 入口替换的逻辑(类似 YAHFA)。
详细步骤如下：
这一步主要是确定 ArtMethod 的内存布局
静态方法是懒加载的，在所在类未被调用前，是未被 resolve 的状态，此时该类的 code entry 只是一个公用的 resolve static stub，我们 inline hook 这个公共入口没有意义。
我们只需要手动 invoke 该方法即可解决，invoke(new Object())，强行塞给他一个 receiver，既达到了 resolve 的目的，也防止方法被成功调用。
hook 方法也是 static 方法，所以也需要 resolve
<= 9.0 时，每个 Dex 存在一个 DexCache，主要目的是跳到下一个方法执行之前，如果是下一个方法在本 Dex 内部，可以通过 index 搜索到下一个方法的 ArtMethod。
而 Hook 方法需要调用的 Backup 方法已经被原方法的 ArtMethod 覆盖，所以需要我们手动填充 DexCache 的 resolvedMethods。
有两条路可走：
这点参考 epic 调用 libart-compiler.so 中的 jitcompile 方法手动编译该类。
跳板代码至少需要使用一个寄存器
在 ARM64 中：
X22 - X28 被 ART 内部用作 Callee Saved
看上去只有被定义为 IP0/IP1 的 X16/X17 可以用，但是 X16 在跳板中被使用。
最后我选择了 X17。
至于 ARM32 则没得选，只有一个 IP(R12)。
结构如上图所属：
jit 就会忽略该方法
Thumb 指令必须所在内存必须满足：
所以 Code Entry 和跳板跳转的地址都必须加以处理
除了一些公共的 Stub 之外，epic 作者的文章中提到如果逻辑类似的两个方法也有可能入口相同。这部分我实验没有发现过。
不过为了防止这种情况的发生，还是和 epic 一样做了判断处理，在 Hook 多个相同入口的时候，跳板形成了“责任链模式”。
implementation 'com.swift.sandhook:hooklib:0.0.2'
@HookClass(Activity.class)
//@HookReflectClass("android.app.Activity")
public class ActivityHooker {
// can invoke to call origin
@HookMethodBackup("onCreate")
@MethodParams(Bundle.class)
static Method onCreateBackup;
@HookMethodBackup("onPause")
static Method onPauseBackup;
@HookMethod("onCreate")
@MethodParams(Bundle.class)
//@MethodReflectParams("android.os.Bundle")
public static void onCreate(Activity thiz, Bundle bundle) {
Log.e("ActivityHooker", "hooked onCreate success " + thiz);
onCreateBackup(thiz, bundle);
}
@HookMethodBackup("onCreate")
@MethodParams(Bundle.class)
public static void onCreateBackup(Activity thiz, Bundle bundle) {
//invoke self to kill inline
onCreateBackup(thiz, bundle);
}
@HookMethod("onPause")
public static void onPause(Activity thiz) {
Log.e("ActivityHooker", "hooked onPause success " + thiz);
onPauseBackup(thiz);
}
@HookMethodBackup("onPause")
public static void onPauseBackup(Activity thiz) {
//invoke self to kill inline
onPauseBackup(thiz);
}
}
SandHook.addHookClass(JniHooker.class,
CtrHook.class,
LogHooker.class,
CustmizeHooker.class,
ActivityHooker.class,
ObjectHooker.class);
provided 'com.swift.sandhook:hookannotation:0.0.2'
// Method register on invoke.
// 储存正在调用的方法
static const vixl::aarch64::Register kArtMethodRegister = vixl::aarch64::x0;
//参数传递
static const vixl::aarch64::Register kParameterCoreRegisters[] = {
vixl::aarch64::x1,
vixl::aarch64::x2,
vixl::aarch64::x3,
vixl::aarch64::x4,
vixl::aarch64::x5,
vixl::aarch64::x6,
vixl::aarch64::x7
};
//
const vixl::aarch64::CPURegList vixl_reserved_core_registers(vixl::aarch64::ip0,
vixl::aarch64::ip1);
//浮点参数
static const vixl::aarch64::FPRegister kParameterFPRegisters[] = {
vixl::aarch64::d0,
vixl::aarch64::d1,
vixl::aarch64::d2,
vixl::aarch64::d3,
vixl::aarch64::d4,
vixl::aarch64::d5,
vixl::aarch64::d6,
vixl::aarch64::d7
};
// Thread Register.
// 线程
const vixl::aarch64::Register tr = vixl::aarch64::x19;
// Marking Register.
// GC 标记
const vixl::aarch64::Register mr = vixl::aarch64::x20;
// Callee-save registers AAPCS64, without x19 (Thread Register) (nor
// x20 (Marking Register) when emitting Baker read barriers).
const vixl::aarch64::CPURegList callee_saved_core_registers(
vixl::aarch64::CPURegister::kRegister,
vixl::aarch64::kXRegSize,
((kEmitCompilerReadBarrier && kUseBakerReadBarrier)
? vixl::aarch64::x21.GetCode()
: vixl::aarch64::x20.GetCode()),
vixl::aarch64::x30.GetCode());
/ Set by the verifier for a method we do not want the compiler to compile. static constexpr uint32_t kAccCompileDontBother = 0x02000000; // method (runtime)
bool isThumbCode(Size codeAddr) {
return (codeAddr & 0x1) == 0x1;
}
#if defined(__aarch64__)
#define Reg0 x17
#define Reg1 x16
#define RegMethod x0
FUNCTION_START(REPLACEMENT_HOOK_TRAMPOLINE)
ldr RegMethod, addr_art_method
ldr Reg0, addr_code_entry
ldr Reg0, [Reg0]
br Reg0
addr_art_method:
.long 0
.long 0
addr_code_entry:
.long 0
.long 0
FUNCTION_END(REPLACEMENT_HOOK_TRAMPOLINE)
#define SIZE_JUMP #0x10
FUNCTION_START(DIRECT_JUMP_TRAMPOLINE)
ldr Reg0, addr_target
br Reg0
addr_target:
.long 0
.long 0
FUNCTION_END(DIRECT_JUMP_TRAMPOLINE)
FUNCTION_START(INLINE_HOOK_TRAMPOLINE)
ldr Reg0, origin_art_method
cmp RegMethod, Reg0
bne origin_code
ldr RegMethod, hook_art_method
ldr Reg0, addr_hook_code_entry
ldr Reg0, [Reg0]
br Reg0
origin_code:
.long 0
.long 0
.long 0
.long 0
ldr Reg0, addr_origin_code_entry
ldr Reg0, [Reg0]
add Reg0, Reg0, SIZE_JUMP
br Reg0
origin_art_method:
.long 0
.long 0
addr_origin_code_entry:
.long 0
.long 0
hook_art_method:
.long 0
.long 0
addr_hook_code_entry:
.long 0
.long 0
FUNCTION_END(INLINE_HOOK_TRAMPOLINE)
FUNCTION_START(CALL_ORIGIN_TRAMPOLINE)
ldr RegMethod, call_origin_art_method
ldr Reg0, addr_call_origin_code
br Reg0
call_origin_art_method:
.long 0
.long 0
addr_call_origin_code:
.long 0
.long 0
FUNCTION_END(CALL_ORIGIN_TRAMPOLINE)
#endif
HookTrampoline* TrampolineManager::installReplacementTrampoline(mirror::ArtMethod *originMethod,
mirror::ArtMethod *hookMethod,
mirror::ArtMethod *backupMethod) {
AutoLock autoLock(installLock);
if (trampolines.count(originMethod) != 0)
return getHookTrampoline(originMethod);
HookTrampoline* hookTrampoline = new HookTrampoline();
ReplacementHookTrampoline* replacementHookTrampoline = nullptr;
Code replacementHookTrampolineSpace;
replacementHookTrampoline = new ReplacementHookTrampoline();
replacementHookTrampoline->init();
replacementHookTrampolineSpace = allocExecuteSpace(replacementHookTrampoline->getCodeLen());
if (replacementHookTrampolineSpace == 0)
goto label_error;
replacementHookTrampoline->setExecuteSpace(replacementHookTrampolineSpace);
replacementHookTrampoline->setEntryCodeOffset(quickCompileOffset);
replacementHookTrampoline->setHookMethod(reinterpret_cast<Code>(hookMethod));
hookTrampoline->replacement = replacementHookTrampoline;
trampolines[originMethod] = hookTrampoline;
return hookTrampoline;
label_error:
delete hookTrampoline;
delete replacementHookTrampoline;
return nullptr;
}
HookTrampoline* TrampolineManager::installInlineTrampoline(mirror::ArtMethod *originMethod,
mirror::ArtMethod *hookMethod,
mirror::ArtMethod *backupMethod) {
AutoLock autoLock(installLock);
if (trampolines.count(originMethod) != 0)
return getHookTrampoline(originMethod);
HookTrampoline* hookTrampoline = new HookTrampoline();
InlineHookTrampoline* inlineHookTrampoline = nullptr;
DirectJumpTrampoline* directJumpTrampoline = nullptr;
CallOriginTrampoline* callOriginTrampoline = nullptr;
Code inlineHookTrampolineSpace;
Code callOriginTrampolineSpace;
Code originEntry;
//生成二段跳板
inlineHookTrampoline = new InlineHookTrampoline();
checkThumbCode(inlineHookTrampoline, getEntryCode(originMethod));
inlineHookTrampoline->init();
inlineHookTrampolineSpace = allocExecuteSpace(inlineHookTrampoline->getCodeLen());
if (inlineHookTrampolineSpace == 0)
goto label_error;
inlineHookTrampoline->setExecuteSpace(inlineHookTrampolineSpace);
inlineHookTrampoline->setEntryCodeOffset(quickCompileOffset);
inlineHookTrampoline->setOriginMethod(reinterpret_cast<Code>(originMethod));
inlineHookTrampoline->setHookMethod(reinterpret_cast<Code>(hookMethod));
if (inlineHookTrampoline->isThumbCode()) {
inlineHookTrampoline->setOriginCode(inlineHookTrampoline->getThumbCodeAddress(getEntryCode(originMethod)));
} else {
inlineHookTrampoline->setOriginCode(getEntryCode(originMethod));
}
hookTrampoline->inlineSecondory = inlineHookTrampoline;
//注入 EntryCode
directJumpTrampoline = new DirectJumpTrampoline();
checkThumbCode(directJumpTrampoline, getEntryCode(originMethod));
directJumpTrampoline->init();
originEntry = getEntryCode(originMethod);
if (!memUnprotect(reinterpret_cast<Size>(originEntry), directJumpTrampoline->getCodeLen())) {
goto label_error;
}
if (directJumpTrampoline->isThumbCode()) {
originEntry = directJumpTrampoline->getThumbCodeAddress(originEntry);
}
directJumpTrampoline->setExecuteSpace(originEntry);
directJumpTrampoline->setJumpTarget(inlineHookTrampoline->getCode());
hookTrampoline->inlineJump = directJumpTrampoline;
//备份原始方法
if (backupMethod != nullptr) {
callOriginTrampoline = new CallOriginTrampoline();
checkThumbCode(callOriginTrampoline, getEntryCode(originMethod));
callOriginTrampoline->init();
callOriginTrampolineSpace = allocExecuteSpace(callOriginTrampoline->getCodeLen());
if (callOriginTrampolineSpace == 0)
goto label_error;
callOriginTrampoline->setExecuteSpace(callOriginTrampolineSpace);
callOriginTrampoline->setOriginMethod(reinterpret_cast<Code>(originMethod));
Code originCode = nullptr;
if (callOriginTrampoline->isThumbCode()) {
originCode = callOriginTrampoline->getThumbCodePcAddress(inlineHookTrampoline->getCallOriginCode());
#if defined(__arm__)
Code originRemCode = callOriginTrampoline->getThumbCodePcAddress(originEntry + directJumpTrampoline->getCodeLen());
Size offset = originRemCode - getEntryCode(originMethod);
if (offset != directJumpTrampoline->getCodeLen()) {
Code32Bit offset32;
offset32.code = offset;
unsigned char offsetOP = callOriginTrampoline->isBigEnd() ? offset32.op.op2 : offset32.op.op1;
callOriginTrampoline->tweakOpImm(OFFSET_INLINE_OP_ORIGIN_OFFSET_CODE, offsetOP);
}
#endif
} else {
originCode = inlineHookTrampoline->getCallOriginCode();
}
callOriginTrampoline->setOriginCode(originCode);
hookTrampoline->callOrigin = callOriginTrampoline;
}
trampolines[originMethod] = hookTrampoline;
return hookTrampoline;
label_error:
delete hookTrampoline;
if (inlineHookTrampoline != nullptr) {
delete inlineHookTrampoline;
}
if (directJumpTrampoline != nullptr) {
delete directJumpTrampoline;
}
if (callOriginTrampoline != nullptr) {
delete callOriginTrampoline;
}
return nullptr;
}
Code TrampolineManager::allocExecuteSpace(Size size) {
if (size > MMAP_PAGE_SIZE)
return 0;
AutoLock autoLock(allocSpaceLock);
void* mmapRes;
Code exeSpace = 0;
if (executeSpaceList.size() == 0) {
goto label_alloc_new_space;
} else if (executePageOffset + size > MMAP_PAGE_SIZE) {
goto label_alloc_new_space;
} else {
exeSpace = executeSpaceList.back();
Code retSpace = exeSpace + executePageOffset;
executePageOffset += size;
return retSpace;
}
label_alloc_new_space:
mmapRes = mmap(NULL, MMAP_PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_ANON | MAP_PRIVATE, -1, 0);
if (mmapRes == MAP_FAILED) {
return 0;
}
exeSpace = static_cast<Code>(mmapRes);
executeSpaceList.push_back(exeSpace);
executePageOffset = size;
return exeSpace;
}
- 主要基于 inline hook，条件不允许时进行 ArtMethod 入口替换
- 接口为注解式，较为友好
- 支持直接 Hook，也支持在插件场景中的 Hook
- 本人极少用 C++，所以 native 代码有些 java style，喜欢 java 的同学还是能一眼看懂的(现在 C++ 是好写多了，基本感受不到和 Java 有多大区别)。汇编代码也很好懂。
- ARM32
- Thumb-2
- ARM64
- 对象方法
- Static 方法
- 构造方法
- JNI 方法
- 系统方法
- 抽象方法(非常不可靠)
-
依赖：
implementation 'com.swift.sandhook:hooklib:0.0.2'
-
写 Hook 项：
- 添加 Hook 项：
[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课
|
|
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
理论上是 Hook 本进程，其他进程你需要自己将 hooklib 注进去，或者可以结合 VA 这种 Sandbox 框架实现。 |
|
|
|
|
|
mark,
|
|
|
mark
|
|
|
|
|
|
|
|
|
|
|
|
yahfa 执行原方法之前没有把 x0 设置程原 artmethod。是可能出问题的，这个我处理了 |
|
|
|
|
|
|
|
|
这个我还没遇到过，可能是我测的 case 比较少，你可以试试我的方案能不能复现。原方法没执行可能是 backup 方法被内联了 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
用反射调原方法现在还有点问题，暂时不要用吧 |
|
|
|
