当前位置: 首页>后端>正文

Xposed模块开发入门保姆级教程

介绍 __

介于网络上的Xposed开发教程过于破烂,所以狐狸狸决定自己写一篇教程来帮助各位想要开发/正在进行开发Xposed模块的开发者。

开始之前 __

在开始之前,你需要准备好:

  • 一台可以安装Xposed框架的手机(推荐LSPosed、Android 10+)
  • 一台可以编写代码并且装有jdk的电脑
  • 一个名叫Android Studio的软件(当然你用IDEA也没问题就是了)
  • 一个反编译软件,如:JADX
  • 一个可以查看布局的App,如:开发者助手

其次,本文假定你已经学会以下内容:

  • 会Java/Kotlin其中一种语言(强烈推荐Kotlin,对模块开发特别友好,为此我专门写了一个kotlin的Xposed模块开发用库来使用,能帮助开发者省下30%~50%甚至更多的代码量,注重模块本身逻辑的编写!不过本期教程不会使用就是了)
  • Java的反射
  • Android的基础套件(如Context、View等,其实这两个就足够了,已经能干很多了)

准备工作 __

创建项目 & 引入依赖 __

首先,我们打开Android Studio创建一个空项目,不需要任何Activity,语言凭个人喜好创建,反正我两种都会讲。
然后,我们需要引入Xposed的库,不过它并没有上传到MavenCentral上,所以我们需要在settings.gradle里修改一下(gradle
7.0+)

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url 'https://api.xposed.info/' }  // 添加这一行即可
    }
}

之后,进入我们app目录下的build.gradle引入xposed的依赖,当然你也可以移除所有依赖来让安装包变小

dependencies {
    compileOnly 'de.robv.android.xposed:api:82' 
    // compileOnly 'de.robv.android.xposed:api:82:sources' // 不要导入源码,这会导致idea无法索引文件,从而让语法提示失效
}

如果你移除了所有依赖只保留了Xposed,你就会发现,你的项目不能build,会直接报错!没关系,我们修复一下:

  • 移除src/res/values/themes.xml里面的主题(注意还有个夜间模式,在values-night文件夹下)
  • 移除AndroidManifest.xml文件里<application ... />中的android:theme="xxx"那一行 移除之后就能build了。我们继续,我们需要创建一个模块作用域文件,在values目录下创建一个名叫arrays的资源文件,它的内容如下:
<resources>
    <string-array name="xposedscope" >
        <!-- 这里填写模块的作用域应用的包名,可以填多个。 -->
        <item>me.kyuubiran.xposedapp</item> 
    </string-array>
</resources>

最后,我们在Run那里编辑一下启动配置,勾选Always install with package manager并且将Launch Options改成Nothing

声明模块 __

做完上一步之后,我们需要声明它是一个Xposed模块,好让框架发现它,这样我们才能激活模块。
回到AndroidManifest.xml文件里,我们将<application ... />改成以下形式(注意,是改成!就是把结尾的/>换成> </application>

<application ... > 
        <!-- 是否为Xposed模块 -->
        <meta-data
            android:name="xposedmodule"
            android:value="true"/>
        <!-- 模块的简介(在框架中显示) -->
        <meta-data
            android:name="xposeddescription"
            android:value="我是Xposed模块简介" />
        <!-- 模块最低支持的Api版本 一般填54即可 -->
        <meta-data 
            android:name="xposedminversion"     
            android:value="54"/>
        <!-- 模块作用域 -->
        <meta-data
            android:name="xposedscope"
            android:resource="@array/xposedscope"/>
</appication>

然后在src/main目录下创建一个文件夹名叫assets,并且创建一个文件叫xposed_init注意,它没有后缀名!!
接着我们需要创建一个入口类,名叫MainHook(或者随便你想取什么名字都行),创建好后回到我们的xposed_init里并用文本文件的方式打开它,输入我们刚刚创建的类的完整路径。如:me.kyuubiran.xposedtutorial.MainHook,同时
注意大小写
到这里,我们声明模块的部分就结束了!怎么样,接下去就到了我们激动人心的编写模块部分了!

模块编写 __

MainHook __

来到我们的MainHook,首先我们需要实现以下Xposed的IXposedHookLoadPackage接口,以便执行Hook操作。具体操作如下
Java:

package me.kyuubiran.xposedtutorial;

import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class MainHook implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        // 过滤不必要的应用
        if (!lpparam.packageName.equals("me.kyuubiran.xposedapp")) return;
        // 执行Hook
        hook(lpparam);
    }

    private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
        // 具体流程
    }
}

Kotlin:

package me.kyuubiran.xposedtutorial

import de.robv.android.xposed.IXposedHookLoadPackage
import de.robv.android.xposed.callbacks.XC_LoadPackage

class MainHook : IXposedHookLoadPackage {
    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
        // 过滤不必要的应用
        if (lpparam.packageName != "me.kyuubiran.xposedapp") return
        // 执行Hook
        hook(lpparam)
    }

    private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
        // 具体流程
    }
}

到这里,我们的准备工作已经完成,安装模块并在框架中激活它!

Xposed模块开发入门保姆级教程,第1张
启用模块.png

反编译 __

终于到了我们反编译apk找hook点的时候了!我这里有一份[猜拳游戏](https://github.com/KyuubiRan/Xposed-guess-
app/releases)的apk,今天我我们要做的事情就是成为 赌圣
我们先打开jadx-gui,选择我们的guess.apk,等他加载完,说明反编译就完成了。
接下去,我们打开应用并且查看它当前布局是什么(我这里使用的是开发者助手专业版)

Xposed模块开发入门保姆级教程,第2张
布局查看.png

如图所示,我们现在处于me.kyuubiran.xposedapp.MainActivity,接着回到我们的jadx中,依次展开并找到这个Activity,就像这样:

Xposed模块开发入门保姆级教程,第3张
jadx反编译.png

Hook activity __

我们最基础的hook方式,就是使用Xposed自带的XposedHelpers.findAndHookMethod,使用方法如下:
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    // 它有两个重载,区别是一个是填Class,一个是填ClassName以及ClassLoader
    // 第一种 填ClassName
    XC_MethodHook.Unhook unhook = XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.MainActivity",    // className
            lpparam.classLoader,    // classLoader 使用lpparam.classLoader
            "onCreate",             // 要hook的方法
            Bundle.class,           // 要hook的方法的参数表,如果有多个就用逗号隔开 
            new XC_MethodHook() {   // 最后一个填hook的回调
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {} // Hook方法执行前  
                @Override
                protected void afterHookedMethod(MethodHookParam param) {} // Hook方法执行后
            });
    // 它返回一个unhook 在你不需要继续hook的时候可以调用它来取消Hook
    unhook.unhook();    // 取消空的Hook 

    // 第二种方式 填Class
    // 首先你得加载它的类 我们使用XposedHelpers.findClass即可 参数有两个 一个是类名 一个是类加载器
    Class<?> clazz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader);
    XposedHelpers.findAndHookMethod(clazz, "onCreate", Bundle.class, new XC_MethodHook() {
        @Override
        protected void afterHookedMethod(MethodHookParam param){
            // 由于我们需要在Activity创建之后再弹出Toast,所以我们Hook方法执行之后
            Toast.makeText((Activity) param.thisObject, "模块加载成功!", Toast.LENGTH_SHORT).show();
        }
    });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    // 它有两个重载,区别是一个是填Class,一个是填ClassName以及ClassLoader
    // 第一种 填ClassName
    val unhook = XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.MainActivity",   // className
        lpparam.classLoader,        // classLoader 使用lpparam.classLoader
        "onCreate",                 // 要hook的方法
        Bundle::class.java          // 要hook的方法的参数表,如果有多个就用逗号隔开 
        object : XC_MethodHook() {  // 最后一个填hook的回调 
            override fun beforeHookedMethod(param: MethodHookParam) {} // Hook方法执行前
            override fun afterHookedMethod(param: MethodHookParam) {} // Hook方法执行后
        })
    // 它返回一个unhook 在你不需要继续hook的时候可以调用它来取消Hook
    unhook.unhook()    // 取消空的Hook
        
    // 第二种方式 填Class
    // 首先你得加载它的类 我们使用XposedHelpers.findClass即可 参数有两个 一个是类名 一个是类加载器
    val clazz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader)
    // 相当于合并了第一、第二两个参数,所以它的使用方式如下:
    XposedHelpers.findAndHookMethod(clazz,"onCreate", Bundle::class.java, object : XC_MethodHook() {
        override fun afterHookedMethod(param: MethodHookParam) {
          // 由于我们需要在Activity创建之后再弹出Toast,所以我们Hook方法执行之后
          Toast.makeText(param.thisObject as Activity, "模块加载成功!", Toast.LENGTH_SHORT).show()
        }
    })
}

其中,param.thisObject代表调用这个方法的对象(如果是静态方法的话可能是为null),我们hook的是Activity的onCreate方法,调用它的自然是这个Activity啦,所以我们把param.thisObject强制转换为Activity类型就能丢给Toast来makeText啦!
安装Xposed模块并且勾选它,如果弹出Toast了,说明你的模块已经生效了!

Xposed模块开发入门保姆级教程,第4张
激活Toast.png

Hook 其他类 __

终于到了我们成为赌圣的时刻!我们需要先分析一下代码,可以看到MainActivity里面有个confirm方法,它里面包含了判断我们胜负的逻辑。

Xposed模块开发入门保姆级教程,第5张

接着看,它在里面new了一个Guess对象,我们CTRL+鼠标左键点开Guess类看看。

Xposed模块开发入门保姆级教程,第6张

可以看到,里面有一个isDrawisWin来判断我们的胜负和平局,接下去我们就需要hook这两个方法! Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isDraw",
            int.class,    // 如果参数是宿主的类,你可以使用findClass来加载那个类或是填写那个类的完整名称!
            new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {
                    // 将返回值设置为false 表示我们不是平局
                    param.setResult(false);
                }
            });
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isWin",
            int.class,
            boolean.class,
            new XC_MethodReplacement() {   // 另一种回调,将方法直接替换成你要执行的内容(其实就是包装过的beforeHook,基本用不到)
                @Override
                protected Object replaceHookedMethod(MethodHookParam param) {
                    return true;
                }
            });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    XposedHelpers.findAndHookMethod(
        "me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isDraw",
        Int::class.java, // 如果参数是宿主的类,你可以使用findClass来加载那个类或是填写那个类的完整名称!
        object : XC_MethodHook() {
            override fun beforeHookedMethod(param: MethodHookParam) {
                // 将返回值设置为false 表示我们不是平局
                param.result = false
            }
        })
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isWin",
        Int::class.java,
        object : XC_MethodReplacement() {   // 另一种回调,将方法直接替换成你要执行的内容(其实就是包装过的beforeHook,基本用不到)
            override fun replaceHookedMethod(param: MethodHookParam): Any {
                // 直接返回true
                return true
            }
        })
}

修改代码之后我们重新安装模块并且启动app,这时我们发现,无论是我们本应该输或者平局,它都算我们胜利!
虽然这么做你赢了游戏,但是别人一眼就看出来了!接下去我来教你如何让对手“配合”你一起演戏!

首先,我们观察点击猜拳按钮的代码,发现isDraw是先被执行的,而且Guess里面的answer是类被实例化之后就创建好了的,并且它也没有方法给我们hook,此时就要出动我们的反射了!
由于isDraw是先被执行的,我们需要在isDraw被执行之前就得使用反射进行“偷梁换柱”,不多bb了上代码!
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    XposedHelpers.findAndHookMethod("me.kyuubiran.xposedapp.Guess",
            lpparam.classLoader,
            "isDraw",
            int.class,
            new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) {
                    try {                        
                        // 首先 我们要拿到他的字段
                        Field fAnswer = param.thisObject.getClass().getDeclaredField("answer");
                        // 并且让它可访问 否则会报非法访问的错误
                        fAnswer.setAccessible(true);
                        int win = 0;
                        // 根据猜拳应用的逻辑 0是石头 1是剪刀 2是布
                        switch ((int) param.args[0]) {  // 首先我们拿到方法的第一个参数 他是int类型
                            case 0:         // 石头->剪刀
                                win = 1;
                                break;
                            case 1:         // 剪刀->布
                                win = 2;
                                break;
                            case 2:         // 布->石头
                                win = 0;
                                break;
                        }
                        // 最后设置answer的值让对手根据我们的出拳来“演戏”
                        fAnswer.set(param.thisObject, win);
                    } catch (Exception ignored) {
                    }
                }
            });
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    XposedHelpers.findAndHookMethod(
        "me.kyuubiran.xposedapp.Guess",
        lpparam.classLoader,
        "isDraw",
        Int::class.java,
        object : XC_MethodHook() {
            override fun beforeHookedMethod(param: MethodHookParam) {
                // 首先 我们要拿到他的字段
                val fAnswer = param.thisObject.javaClass.getDeclaredField("answer")
                // 并且让它可访问 否则会报非法访问的错误
                fAnswer.isAccessible = true
                // 根据猜拳应用的逻辑 0是石头 1是剪刀 2是布
                val win = when (param.args[0] as Int) { // 首先我们拿到方法的第一个参数 他是Int类型 就是我们的出拳
                    0 -> 1         // 石头->剪刀
                    1 -> 2         // 剪刀->布
                    2 -> 0         // 布->石头
                    else -> 0
                }
                // 最后设置answer的值让对手根据我们的出拳来“演戏”
                fAnswer.set(param.thisObject, win)
            }
        })
}

重新安装运行,完美!现在对手会配合我们出拳来故意让我们取得胜利!从此,你就是赌圣!

另一种方式 __

Xposed其实还提供了另一种方式进行Hook,就是使用XposedBridge.hookMethod
其实基本上没有太大区别,只不过方法是你自己寻找罢了,举个例子:
Java:

private void hook(XC_LoadPackage.LoadPackageParam lpparam) {
    Class<?> clz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader);
    for (Method m : clz.getDeclaredMethods()) {
        if (m.getName().equals("onCreate")) {
            XposedBridge.hookMethod(m, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) {
                    Toast.makeText((Activity) param.thisObject, "我又Hook了MainActivity的onCreate方法!", Toast.LENGTH_SHORT).show();
                }
            });
        }
    }
}

Kotlin:

private fun hook(lpparam: XC_LoadPackage.LoadPackageParam) {
    val clz = XposedHelpers.findClass("me.kyuubiran.xposedapp.MainActivity", lpparam.classLoader)
    for (m in clz.declaredMethods) {
        if (m.name == "onCreate") {
            XposedBridge.hookMethod(m,object : XC_MethodHook() {
                override fun afterHookedMethod(param: MethodHookParam) {
                    Toast.makeText(param.thisObject as Activity,"我又Hook了MainActivity的onCreate方法!",Toast.LENGTH_SHORT).show()
                }
            })
        }
    }
}

结束 __

以上便是Xposed入门教程了,应该是目前最友好的教程了,该讲的基本都讲了(虽然废话可能有点多)剩下就看造化了(

Q & A __

Q1: 什么时候用beforeHook,什么时候用afterHook,它们的区别是什么?
A1:
你可以把before当成方法第一行执行之前,after当成方法最后一行执行完毕准备返回。如果你要修改参数,那就用before,如果你要修改返回值,那就用after,如果你不需要方法执行直接结束方法,那就用before,当然他俩是可以同时使用的,看具体情况。综合上述,基本用before就行了。

本文遵守 Attribution-NonCommercial 4.0
International 许可协议。
[图片上传失败...(image-eddc23-1707752748726)]


https://www.xamrdz.com/backend/33g1941781.html

相关文章: