Framework定制-集成Dobby模块

已于 2024-01-16 09:41:25 修改
阅读量770 收藏 1
点赞数
分类专栏： 安卓系统 文章标签： java android 开发语言
于 2022-11-27 10:23:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44348983/article/details/128060968
版权

前言

上次分享了，源码集成YAHFA，有个同学私信，怎么Hook so层，作为一个爱分享的人，今天给你解决方案。这次就接着把上次YAHFA框架集成的代码稍微改一下，不用大动，不明白的人，先看一下上次的YAHFA框架集成。

先在Application类，插入加载so的代码

- frameworks/base/core/java/android/app/Application.java

在上次的基础上，插几行代码即可
    /* package */ final void attach(Context context) {
        attachBaseContext(context);
        mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
        // add start
        try{
            JLog.print_info("Process-Info", "Application->attach ProcessName:" + getProcessName());

            if (isHook == false){
                AntiyHookManager hook = (AntiyHookManager)context.getSystemService(Context.ANTIY_HOOK_SERVICE);
                hook.getConfig();
                if (hook.checkHookDex(getProcessName())){
                    int flags = context.getApplicationInfo().flags;
                    if (flags > 0 && ((flags&ApplicationInfo.FLAG_SYSTEM)!=1)){
                        String apkPath = "/data/data/" + context.getPackageName() + "/AntiyPlugin.apk";
                        String soPath = "/data/data/" + context.getPackageName() + "/AntiyPlugin.so";
                        AntiyHook.moveApkToData(hook.hookdex.pluginPath, apkPath);
                        AntiyHook.unZipApkSoToData(hook.hookdex.pluginPath, soPath);
                        AntiyHook.startHook(context.getClassLoader(), apkPath, soPath);
                        isHook = true;
                    }
                }
            }

        } catch(Exception e){
            Log.e("AntiyHook_Application", e.toString());
        }
        // add end
    }

AntiyHook类在上次帖子的基础上，稍加修改，加一个函数即可（Antiy暴露了我的东家）

package android.app;


import android.content.Context;
import android.os.Build;
import android.os.Environment;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import dalvik.system.DexClassLoader;
import android.os.FileUtils;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;


public class AntiyHook {
	public static final String TAG = "AntiyHook";

    static {
    	init(Build.VERSION.SDK_INT); //android 9 = 28
    }


    public static void unZipApkSoToData(String srcApkPath, String dstSoPath){
        try {
            File zipFile = new File(srcApkPath);
            if(!zipFile.exists()) {
                return ;
            }
            ZipInputStream zin = new ZipInputStream(new FileInputStream(zipFile));
            ZipEntry entry;
            while ( (entry = zin.getNextEntry()) != null){
                if ( entry.getName().contains(".so")){
                    if(System.getProperty("os.arch").indexOf("64") >= 0) {
                        if ( entry.getName().contains("arm64-v8a")){
                            Log.i(TAG, "copy so file :" + entry.getName());
                            writeSoFile(zin, dstSoPath);
                        }
                    }else{
                        if ( entry.getName().contains("armeabi-v7a")){
                            Log.i(TAG, "copy so file :" + entry.getName());
                            writeSoFile(zin, dstSoPath);
                        }
                    }
                }
            }
            zin.closeEntry();
        }
        catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

    public static void writeSoFile(ZipInputStream zin, String path){
        FileOutputStream out = null;
        try{
            File fi = new File(path);
            if (!fi.exists()) {
                fi.getParentFile().mkdirs();
                fi.createNewFile();
            }
            out = new FileOutputStream(fi);
            int len;
            byte[] buffer = new byte[2048];
            while ((len = zin.read(buffer)) != -1) {
                out.write(buffer, 0, len);
                out.flush();
            }
        } catch (Exception e){
            Log.e(TAG, e.toString());
        } finally {
            try{
                if (out != null){
                    out.close();
                }
            } catch (Exception e){
                Log.e(TAG, e.toString());
            }
            setPermission(path);
        }
    }


    public static void moveApkToData(String srcFileName, String dstFileName){
        deleteDataFile(dstFileName);
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream(srcFileName);
            out = new FileOutputStream(dstFileName);
            byte[] bytes = new byte[1024];
            int i;
            while ((i = in.read(bytes)) != -1)
                out.write(bytes, 0, i);
        } catch (IOException e) {
            Log.e(TAG, e.toString());
        } finally {
            try {
                if (in != null)
                    in.close();
                if (out != null){
                    out.flush();
                    out.close();
                }
            } catch (IOException e) {
                Log.e(TAG, e.toString());
            }
            setPermission(dstFileName);
        }

    }


    public static void setPermission(String path){
        try{
            File file = new File(path);
            if (file.exists()){
                int perm = FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO;
                FileUtils.setPermissions(path, perm, -1, -1);//将权限改为777   
            }
  
        }catch (Exception e) {
            Log.e(TAG, e.toString());
        }

    }


    public static void deleteDataFile(String fileName){
        try {
            File file = new File(fileName);
            if (file.exists()){
                file.delete();
            }
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        } 
    }

    public static void loadPluginSo(String soPath){
        try{
            File file = new File(soPath);
            if (file.exists()){
                Log.i(TAG, "load so src:" + soPath);
                System.load(soPath);
                file.delete();//用完就删否则不会更新
            }
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        } 

    }

    public static void startHook(ClassLoader originLoader, String apkPath, String soPath){
    	try{
            Log.i(TAG, "in AntiyHook startHook");
    		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) {
	            DexClassLoader pluginLoader = new DexClassLoader(
	                    apkPath, null, null, originLoader);
            	doHookDefault(pluginLoader, originLoader);
            }
            loadPluginSo(soPath);
        }  catch (Exception e) {
            Log.e(TAG, e.toString());
        }

    }


    public static void doHookDefault(ClassLoader pluginLoader, ClassLoader originLoader) {
        try {
            Log.i(TAG, "in AntiyHook doHookDefault");
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) {
                Class<?> hookInfoClass = Class.forName("com.antiy.HookInfo", true, pluginLoader);
                String[] hookClassNames = (String[]) hookInfoClass.getField("hookClassNames").get(null);
                for (String hookClassName : hookClassNames) {
                    doHookItemDefault(pluginLoader, hookClassName, originLoader);
                }
            }
        } catch (Exception e) {
            Log.e(TAG, "doHookDefault:" + e.toString());
        }
    }

    public static void doHookItemDefault(ClassLoader patchClassLoader, String hookItemName, ClassLoader originClassLoader) {
        try {
            Log.i(TAG, "in AntiyHook doHookItemDefault:" + hookItemName);
            Class<?> hookItem = Class.forName(hookItemName, true, patchClassLoader);

            String className = (String) hookItem.getField("className").get(null);
            String methodName = (String) hookItem.getField("methodName").get(null);
            String methodSig = (String) hookItem.getField("methodSig").get(null);

            if (className == null || className.equals("")) {
                Log.w(TAG, "No target class. Skipping...");
                return;
            }

            Class<?> clazz = Class.forName(className, true, originClassLoader);
            if (clazz == null){
                Log.e(TAG, "Cannot find class " + className);
                return;
            }

            Method hook = null;
            Method backup = null;
            for (Method method : hookItem.getDeclaredMethods()) {
                if (method.getName().equals("hook") && Modifier.isStatic(method.getModifiers())) {
                    hook = method;
                } else if (method.getName().equals("backup") && Modifier.isStatic(method.getModifiers())) {
                    backup = method;
                }
            }
            if (hook == null) {
                Log.e(TAG, "Cannot find hook for " + className + ":" + methodName);
                return;
            }

            // has to visibly init the classes
            // see the comment for function Utils.initClass()
            if(initClass() != 0) {
                Log.e(TAG, "Utils.initClass failed");
            }

            findAndBackupAndHook(clazz, methodName, methodSig, hook, backup);
        } catch (Exception e) {
            Log.e(TAG, "doHookItemDefault:" + e.toString());
        }
    }

    public static void findAndHook(Class targetClass, String methodName, String methodSig, Method hook) {
        hook(findMethod(targetClass, methodName, methodSig), hook);
    }

    public static void findAndBackupAndHook(Class targetClass, String methodName, String methodSig,
                                            Method hook, Method backup) {
        Log.i(TAG, "in AntiyHook findAndBackupAndHook:" + methodName);
        backupAndHook(findMethod(targetClass, methodName, methodSig), hook, backup);
    }

    public static void hook(Object target, Method hook) {
        backupAndHook(target, hook, null);
    }

    public static void backupAndHook(Object target, Method hook, Method backup) {
        if (target == null) {
            throw new IllegalArgumentException("null target method");
        }
        
        if (hook == null) {
            throw new IllegalArgumentException("null hook method");
        }

        if (!Modifier.isStatic(hook.getModifiers())) {
            throw new IllegalArgumentException("Hook must be a static method: " + hook);
        }
        checkCompatibleMethods(target, hook, "Original", "Hook");
        if (backup != null) {
            if (!Modifier.isStatic(backup.getModifiers())) {
                throw new IllegalArgumentException("Backup must be a static method: " + backup);
            }
            checkCompatibleMethods(target, backup, "Original", "Backup");
        }

        if(initClass() != 0) {
            Log.e(TAG, "initClass failed");
        }

        if (!backupAndHookNative(target, hook, backup)) {
            throw new RuntimeException("Failed to hook " + target + " with " + hook);
        }
    }

    private static Object findMethod(Class cls, String methodName, String methodSig) {
        if (cls == null) {
            throw new IllegalArgumentException("null class");
        }
        if (methodName == null) {
            throw new IllegalArgumentException("null method name");
        }
        if (methodSig == null) {
            throw new IllegalArgumentException("null method signature");
        }
        return findMethodNative(cls, methodName, methodSig);
    }

    private static void checkCompatibleMethods(Object original, Method replacement, String originalName, String replacementName) {
        ArrayList<Class<?>> originalParams;
        if (original instanceof Method) {
            originalParams = new ArrayList<>(Arrays.asList(((Method) original).getParameterTypes()));
        } else if (original instanceof Constructor) {
            originalParams = new ArrayList<>(Arrays.asList(((Constructor<?>) original).getParameterTypes()));
        } else {
            throw new IllegalArgumentException("Type of target method is wrong");
        }

        ArrayList<Class<?>> replacementParams = new ArrayList<>(Arrays.asList(replacement.getParameterTypes()));

        if (original instanceof Method
                && !Modifier.isStatic(((Method) original).getModifiers())) {
            originalParams.add(0, ((Method) original).getDeclaringClass());
        } else if (original instanceof Constructor) {
            originalParams.add(0, ((Constructor<?>) original).getDeclaringClass());
        }


        if (!Modifier.isStatic(replacement.getModifiers())) {
            replacementParams.add(0, replacement.getDeclaringClass());
        }

        if (original instanceof Method
                && !replacement.getReturnType().isAssignableFrom(((Method) original).getReturnType())) {
            throw new IllegalArgumentException("Incompatible return types. " + originalName + ": " + ((Method) original).getReturnType() + ", " + replacementName + ": " + replacement.getReturnType());
        } else if (original instanceof Constructor) {
            if (replacement.getReturnType().equals(Void.class)) {
                throw new IllegalArgumentException("Incompatible return types. " + "<init>" + ": " + "V" + ", " + replacementName + ": " + replacement.getReturnType());
            }
        }

        if (originalParams.size() != replacementParams.size()) {
            throw new IllegalArgumentException("Number of arguments don't match. " + originalName + ": " + originalParams.size() + ", " + replacementName + ": " + replacementParams.size());
        }

        for (int i = 0; i < originalParams.size(); i++) {
            if (!replacementParams.get(i).isAssignableFrom(originalParams.get(i))) {
                throw new IllegalArgumentException("Incompatible argument #" + i + ": " + originalName + ": " + originalParams.get(i) + ", " + replacementName + ": " + replacementParams.get(i));
            }
        }
    }


    private static native boolean backupAndHookNative(Object target, Method hook, Method backup);

    public static native Object findMethodNative(Class targetClass, String methodName, String methodSig);

    private static native void init(int sdkVersion);

    public static int initClass() {
        if(shouldVisiblyInit()) {
            long thread = getThread();
            return visiblyInit(thread);
        }
        else {
            return 0;
        }
    }

    private static native boolean shouldVisiblyInit();
    private static native int visiblyInit(long thread);
    private static native long getThread();
}

然后编译源码刷机

这样在应用启动初期，就会加载含有Dobby框架的so，现在来写插件，在插件中集成Dobby

1 修改CMakefile文件把so名称设置为AntiyPlugin.so

2 新建libs文件夹放入dobby.a静态库（参考：Dobby集成 - 简书）

3 在cpp文件夹下放入dobby头文件

4 编写代码hook  open试试



定义函数指针
typedef int(*pFunc_Open)(const char *, int , ...);
pFunc_Open Hook::orgin_open = nullptr;
 
定义用于替换的函数
int fake_open(const char *path, int flag, ...){
    va_list args;
    va_start(args, flag);
    int mode = va_arg(args, int);
    va_end(args);
    LOGI("open hook path -> %s ", path);
    return orgin_open(path, flag, mode); //调用原函数
}
 
对open函数进行hook
void hook_open() {
    void* addr = DobbySymbolResolver("libc.so", "open");
    if (addr != nullptr){
        if (DobbyHook((void*)addr, (void*)(fake_open), (void**)&orgin_open) == RT_SUCCESS){
            LOGI("open hook success");
        }else{
            LOGI("open hook failed");
        }
    }
}

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    jint result = -1;
	
	//获取JNIEnv环境
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_4) != JNI_OK) {
        printf("JavaVm fail to get JNIEnv\n");
        return -1;
    }

    ...
    hook_open();
    ...

}

其他就跟上次帖子集成YAHFA时的操作一致，放入config.js, push 插件到/data/local/tmp/就行了

现在来看一下效果：

 （上面这个应用会检测调试信息，通过对open函数的hook，也能发现部分踪迹, /proc/self/status文件可以查看是否被调试）

YoooHaaa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dubbo框架的简单使用
songziyuan_的博客
07-06 305
dubbo的简单使用，作者小白一枚
Dobby:轻量级，多平台，多体系结构的钩子框架
03-22
多比 Dobby一个轻量级，多平台，多体系结构的利用钩子框架。 最小和模块化的库 多平台支持（Windows / macOS / iOS / Android / Linux） 多种架构支持（X86，X86-64，ARM，ARM64） 无需STL即可清除代码（轻松移植到内核） 插件支持（SymbolResolver，SupervisorCallMonitor） iOS内核漏洞利用支持（Gollum？） 入门 git clone https://github.com/jmpews/Dobby.git --depth=1 cd Dobby/example/ mkdir build; cd build; cmake .. 或下载 快速演示 iOS ARM64E void *posix_spawn_ptr = __builtin_ptrauth_strip((void *)posix_
Android项目中添加Dobby(inline hook)
哆啦安全
05-01 780
inline hook 鸿蒙(HarmonyOS)APP开发实战课程(入门到精通)
推荐开源项目：Dobby——轻量级多平台exploit钩子框架
最新发布
gitblog_00078的博客
05-11 442
推荐开源项目：Dobby——轻量级多平台exploit钩子框架 项目地址:https://gitcode.com/jmpews/Dobby 1、项目介绍 Dobby是一个强大且灵活的exploit钩子框架，旨在为开发者提供跨平台、跨架构的动态代码注入和替换功能。设计小巧且模块化，使得Dobby在保持高效性能的同时，具有高度可扩展性。该项目深受诸如 Frida-gum、MinHook、Substra...
dubbo框架的使用
刘刘刘刘刘牛皮的博客
11-15 353
一：什么是dubbo框架 Dubbo是一个分布式服务的框架，致力于提供高性能和透明化PRC远程服务调用方案，以及SOA服务治理方案。一句话来说dubbo就是远程服务调用的分布式框架 二：dubbo作用： 1.透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。 2.软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。 ...
hookZz,Dobby,xHook,consoleDebugger
Codeooo 博客
11-10 8768
【代码】hookZz,Dobby,xHook,consoleDebugger。
Hanabi-Dobby
11-21
【描述】"Hanabi-Dobby iOS" 提供了一个集成的解决方案，结合了Hanabi和Dobby的优势，帮助开发者更有效地处理iOS应用中的复杂问题。Hanabi可能是一个自定义的编译器框架或中间件，用于改进代码编译和运行时性能；而...
dobbybot:Dobby bot源代码
05-15
Dobby Bot设定指南制成： discord.js@12.5.1 Nodejs@14.4 Mongodb 该机器人永久运行，并确保其正常运行时间达到99％。安装 :robot: 您需要安装和 。 在这种情况下，我使用可以更轻松地进行编辑，并在保存文件时自动...
dobby-shop-serverless-ecommerce:Dobby Shop是一个演示项目，用于展示如何利用云的最大优势开发和部署无服务器应用程序
03-09
**无服务器架构与Dobby Shop** 无服务器架构（Serverless）是一种云计算模型，它允许开发者构建和运行应用程序而无需管理底层服务器。在这种架构下，云提供商负责资源的管理和分配，只按实际执行的代码量计费，从而...
多比（Dobby）：多比（Dobby），友好的管理员精灵，会处理您所有（不需要的）管理员通知
02-05
友好的管理员精灵多比（Dobby）会处理所有（不需要的）管理员通知。 安装 使用安装： $ composer require tfrommen/dobby 要么： 。 将内容上载到Web服务器上的/wp-content/plugins/目录。 通过WordPress中的...
dobby 的inlinehook原理
iOS_Princekin的博客
04-19 2102
dobby 的inlinehook，通过取出一页，插入跳转到新方法的汇编代码，然后 通过 mach_vm_remap 方法进行实现 PUBLIC MemoryOperationError CodePatch(void *address, uint8_t *buffer, uint32_t buffer_size) { // 新创建一页，用于在新创建的页上patch 代码 addr_t remap_dummy_page = (addr_t)mmap(0, page_size, PRO
【安卓逆向】xposed hook native 函数
weixin_44862184的博客
09-28 5529
xposed 集成dobby 实现 hook native 函数
分享一个自己做的函数抽取壳
zhangmiaoping23的专栏
01-12 934
一、概述 项目中慢慢开始，写一些简单的 kotlin类了，挺方便的一个语言，借鉴了不少脚本语言的特点。刚开始用，有些点经常要翻越，特别记录下。 二、常用的几个复合符号 《Kotlin 实战》小人系列，的这本书里 画的图很清晰了，我又重画了一遍。 2.1、 ?.安全调用符 !这里写图片描述 if (foo != null){ return foo.bar() }else{ return null } 1 2 3 4 5 6 2.2、 ?: 2.3、 as? 2.4、 !! ...
13、fishhook原理&Dobby
Holothurian
04-20 1428
Dobby原理: 运行时对目标函数的汇编代码替换,修改的是内存中MachO的代码段Dobby替换汇编代码时,对原始函数的调用,会影响栈的拉伸和平衡在真实HOOK场景中,我们拿不到符号名称,只能对地址进行HOOKHOOK地址时,需要加上PAGEZERO和ASLR。
成熟的App会Hook自己
fenfei331的博客
06-11 1288
一、目标 李老板： 奋飞呀，我都是自己了，还不是想怎么玩就怎么玩，还用Hook这么麻烦吗？ 奋飞：男人要对自己狠一点。 我有一个 libtest.so，我调用它后，它会使用 android_log_print 输出一些信息，我想让它输出的内容加点私货。动手吧。 so hook Dobby 二、步骤 先把so调用起来 把so放在cpp的同级目录 jniLibs下面。 然后跑起来，输出： 2021-06-11 09:45:11.185 17916-18002/com.fenfei.dobbydemo D/
iOS中几种hook代码的方法
老猿的自留地
02-22 1094
iOS中Object-C代码的主要hook方式。其原理是利用OC的Runtime特性，动态改变SEL（方法编号）和IMP（方法实现）的对应关系，达到OC方法调用流程改变的目的。比如， 我们可以通过hook字典NSMutableDictionary的 setObject:forKey和removeObjectForKey:方法，帮助其实现空安全。2.dobby是一个开源的第三方框架，主要用于C、C++等静态代码的hook。其原理是，直接修改目标函数的头部代码（修改的是内存中MachO的代码段。
2024山东省考笔试面试比例，成熟的App会Hook自己，2024非科班生的Android面试之路
2401_84102956的博客
04-06 711
对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。下面是部分资料截图，诚意满满：特别适合有开发经验的Android程序员们学习。不论遇到什么困难，都不应该成为我们放弃的理由！如果你看到了这里，觉得文章写得不错就给个赞呗？本文已被。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值