精华内容
下载资源
问答
  • ##Xposed框架的使用框架是一款开源框架,其功能是可以在不修改APK的情况下影响程序运行(修改系统)的框架服务,基于它可以制作出许多功能强大的模块,且在功能不冲突的情况下同时运作。Xposed就好比是模块化手机的...
  • 4.42安卓模拟器Xposed框架链接: https://pan.baidu.com/s/1depSSHCy0KYcFZzkPH7aZQ 密码: vmyr 5.11安卓模拟器Xposed框架链接:() https://pan.baidu.com/s/1erZD4gMk1MQdVklnrmSuLg 密码: s4j4 夜神模拟器默认...
  • 一、前言 ...看到上面说的那么多,感觉这个功能必须要搞起来了,好处太多了,下面咋们就开始操作了,但是在这之前一定要先熟悉Xposed框架的使用规则,还不了解的同学可以去这里查看:Xposed框架的使用规则
  • XPOSED框架

    2019-04-14 16:22:06
    安卓手机APK运行前进行HOOK,调试。在不改变APK的情况下对APK进行改变
  • 夜神模拟器5.1.1安卓模拟器Xposed框架,和hook例子。目标测试APP 和 hook 插件源码 全部都有,包括 xposed 。
  • 原包名:de.robv.android.xposed 修改过后的包名:com.anticc.android.check 包含 api.jar (开发模块调用) XposedInstaller_3.1.5-debug.apk (模块管理) 以及 要刷入的 xposed-v89-sdk25-arm64.zip
  • 集齐全网最全的Xposed框架.zip,里面包含5个框架,可以满足大部分手机型号的需求,需要的朋友欢迎下载
  • 夜神安卓模拟器安装xposed框架-附件资源
  • xposed框架安装包合集

    2018-04-25 16:33:04
    xposed3.1.1是高版本android 系统xposed安装包,2.5.1是4.4以下的,3.0是4.4以上。看手机系统版本来选择安装
  • Xposed框架核心思想在于将Java层普通函数注册成本地JNI方法,以此来变相实现hook机制(放在文章开头的话很重要哦,记住!)。Xposed框架的技术核心建立在Jvm原生的JNI机制之上,为了对Xposed框架进行深入分析,同时...
  • xposed框架

    2018-03-14 22:09:03
    手机刷这个xposed框架然后在酷安上搜索xposed搜索模块,安装模块实现很多功能
  • Xposed框架以及安装器

    2018-07-13 23:53:23
    其中包含了一个Xposed installer安装包和安卓系统5.0、5.1以及6.0的框架!
  • 早前也有一款可以实现钉钉考勤的Xposed框架模块,这是一个新的钉钉打卡辅助工具,可修改钉钉打开定位位置,支持时间控制,修改之后立即生效,无需重启手机。无需在设置中开启“模拟位置”权限。
  • 本资源是在Xda官网下载下来的Xposed的arm64框架针对SDK27,也就是安卓8.1系统的Xposed框架
  • 里面包含了安卓6.0到8.1最新得xposed zip包,使用recovery可以刷入,推荐TRWP 安卓版本与sdk对应关系,压缩包内都是用sdk标记,请按照下面得对应表找到合适得安卓版本 安卓版本 SDK Level Android 8.1 27 Oreo ...
  • 本篇文章介绍了Android中Xposed框架的使用,详细的介绍了修改系统位置信息实现自身隐藏功能实例,有需要的朋友可以了解一下。
  • Xposed框架包(含sdk21-23)

    2017-02-16 16:26:00
    Xposed框架(含sdk21-23), arm & arm64 & x86
  • Xposed框架必备jar包

    2017-11-08 21:07:29
    Xposed框架必备jar包(含:XposedBridgeApi54.jar),十分好用,方便查找........有什么不理解欢迎咨询
  • Xposed框架包(sdk23-27即安卓6.0-8.1---32和64都有).rar------------亲测可用,积分便宜
  • 华为专用Xposed框架

    2014-04-13 20:14:44
    转为华为系统设计, XposedInstall EMUI
  • 微信xposed 框架

    2018-12-16 12:09:35
    一款微信xopsed框架 提供大家交流与学习,有什么需要优化的给我留言
  • QQLuckyMoney(QQ红包插件)是一款能够支持QQ抢红包的Xposed框架模块,由veryyoung制作,抢红包插件专业户。
  • Xposed框架的基本使用案例

    热门讨论 2016-10-15 13:33:18
    Xposed框架的基本使用案例
  • Xposed框架:xda的这一也是一个言简意赅的Android武器了,整顿了全部app_process binary,就可以hook全部。十分牛叉。功能介绍Xposed框架是一款能够 不在改动APK的状况下危害程序执行(修改系统)的框架服务项目,根据...

    Xposed框架:xda的这一也是一个言简意赅的Android武器了,整顿了全部app_process binary,就可以hook全部。十分牛叉。

    功能介绍

    Xposed框架是一款能够 不在改动APK的状况下危害程序执行(修改系统)的框架服务项目,根据它能够 制做出很多功能齐全的模块,且在作用不矛盾的状况下另外运行。

    当今,Per APP Setting(为每一个应用设

    Xposed框架:xda的这一也是一个言简意赅的Android武器了,整顿了全部app_process binary,就可以hook全部。十分牛叉。

    功能介绍

    Xposed框架是一款能够 不在改动APK的状况下危害程序执行(修改系统)的框架服务项目,根据它能够 制做出很多功能齐全的模块,且在作用不矛盾的状况下另外运行。

    当今,Per APP Setting(为每一个应用设置独立的dpi或改动管理权限)、Cydia、XPrivacy(避免泄漏)、对原生态Launcher更换标志等运用或作用均根据此框架。

    应用基本原理如上

    对运用各种各样设置 可限定应用权限

    1、进到xposed外 挂模块,点运用模块,把应用设置打勾,重启手机

    2、开启应用设置,这时候会把程序流程手机软件载入进去,搜索,点一下,进到QQ应用设置,点打开,把长驻运行内存打勾,点最右上方的储存标志,撤出应用设置,重启手机。

    3、别的的程序流程如手机微信等,包含sense,你都能够那样设置长驻运行内存,那样QQ等程序流程不容易在后台管理被杀掉。

    版本更新

    This test version uses a database to manage the list of downloadable modules.

    Only install it if you want to test this new development. Otherwise, please install/stay on 2.6.1.

    [展开全部↓]

    展开全文
  • 总会有人需要使用Xposed框架的,但是使用这个框架需要root刷机,解锁bootloader之类的方式才可以用,但是现在使用应用转生APP,就可以完全不用这么麻烦了,只需要用应用转生就可以免root使用Xposed框架,一定要记得...

    554192cb574fcd2b9c89a00c58d16d44.gif

      今天分享一款虚拟框架软件,有点类似太极app,都是可以使用app进行功能模块的加载和安装,不过与其他不同的是需要进行转生才行!总会有人需要使用Xposed框架的,但是使用这个框架需要root刷机,解锁bootloader之类的方式才可以用,但是现在使用应用转生APP,就可以完全不用这么麻烦了,只需要用应用转生就可以免root使用Xposed框架,一定要记得下载Xopsed模块安装就可以了,而且还没有任何的广告,十分的方便简洁!

       但是要注意的就是转生过程中需要卸载你转生的应用,才可以正常的安装,所以用之前请先做好备份,而且应用转生成功之后可能出现于MIUI/华为等第三方ROM的系统分身功能冲突,记得删除全部的系统分身,记得要下载Xposed模块进行安装,简单但是却非常的实用,而且无任何的广告。

    应用介绍

       应用转生是一款可以让广大玩机爱好者使用xposed模块的神器,无需root权限,无需解BL锁即可体验各种开源的xposed模块,比如钉钉打卡、修改微信运动步数,让你的玩机生活更加丰富多彩。    

    应用截图

    198b57935c927c6d64a9285ee268200a.png

    91086006fe5707c68cab7d2a060e6d4e.png

    873b7960b6ba3a9e840f1a9c0dc2dba7.png

    应用功能

      1、这是一个帮助你免Root使用Xposed模块的软件。

      2、支持市面是各种常用的框架,如XQ、微X、应用变量...。

      3、在左上角便可将插件导入进来,不过需要将原插件下卸载再安装一次。

      4、可以让用户体验到功能更加丰富的应用程序。

      5、用户可以在这里面进行模块的安装,这一点是不错的。刷机显得可有可无,就好像IOS系统的越狱一样。

    应用下载

    e1219b84330614c640ba9fda54c3fc0b.png

    请在公众号“小暗的DVD”后台发送

    关键词“app131”获取资源

    245a55da48b687e3192a10b66defdfdb.png

    免责声明:暗转列机旗下软件均来源于网络,仅作学习和交流,请勿用于任何商业或其他非法用途,如有侵权请联系责编删除!

    7aef50febbba42748bad9afbe13dc892.png

    收集不易,若对你有所帮助,别忘了点个 c63dbe340e11d464cc5c991b4ab803f4.gif

    展开全文
  • 从今天开始宸道要更改推文频率了,现在周一和周四更新推文,小伙伴们注意一下推文时间噢,好啦,话不多说进入今天的在主题Xposed框架是一款可以在不修改APK的情况下影响程序运行(修改系统)的...

    点击蓝字

    默默关注

    新的一周又是新的开开始,希望小伙伴们学业有成事业成功,

    相信不少看宸道的小伙伴们有注意到,公众号上面的更新的逆向文章,已经快要讲完了,有需要的小伙伴们可以从第一篇开始看,好系统的学习一遍。

    从今天开始宸道要更改推文频率了,现在周一和周四更新推文,小伙伴们注意一下推文时间噢,好啦,话不多说进入今天的在主题

    760c756dfc06199f046b0007cf48c0d9.png

    Xposed框架是一款可以在不修改APK的情况下影响程序运行(修改系统)的框架服务,基于它可以制作出许多功能强大的模块,且在功能不冲突的情况下同时运作。对原生Launcher替换图标等应用或功能均基于此框架。

    1

    安装xposed框架

    框架的安装有两种情况:系统5.0以上及以下,目前模拟器或者手机都是5.0以上的版本,先来演示一下5.0以上框架的安装。

    Xposed 框架需要有ROOT授权才能安装,安卓的一切高级应用都需要ROOT权限。

    1.安装Xposed 框架的安装包,安装完成后打开进入主界面,如下图所示。

    67649a10f8426870d7947e83ac4e55bd.png

    2.提示“框架未安装”,需要进行框架安装,如下图所示。

    50f1a38417448fb86071ec2422ab8247.png

    3.提示要重新安装,还是恢复安装,选择重新安装,如下图所示。

    431ffb47f3a972555250299cd3e079cc.png

    4.安装完成后,重新启动,由于雷电模拟器不支持自启动,所以需要手动关闭重启,如下图所示。

    34ae0bcf29cfed6dcf0a5932ffaa3a40.png

    5.启动完成以后,正常的界面显示已激活,如下图所示。

    ef6f96b656f34f71e1065e77d86ad4e0.png                   

    6.安装完成后点击左上角,这里只需要用到模块和日志选项。

    如果选择了一个新的模块的话就需要重新启动一下模拟器才能生效。

    7.日志窗口介绍,如下图所示。

    d4202f0ae423d48bf1103aa9dba89053.png

    e3e4b9f8384e5aa13254c4327a13084d.png

    Xposed插件开发

    2修改配置文件

    首先打开eclipse,创建安卓项目在AndroidManifest.xml文件里配置,记住name属性值不能修改,只修改value属性。

    1.添加标识,让系统识别这是插件,如下图所示。

    80951b13e524ec924fdb972e4d2a39ce.png

    2.载入HOOK模块之后显示的信息可以自定义,如下图所示。

    a039015e0036cfd963889d21325076c8.png

    3.规定jar包的版本信息也可以自定义版本,如下图所示。

    39b93edb45bad84be2315a988e511fa5.png

    3添加第三方jar包

    配置文件修改完成后,添加第三方jar包,具体步骤如下:

    1.新建文件夹命名为lib,把XposedBridgeApi.jar这个jar包放进去。

    2.找到lib下的jar包右键有个build path 如果有add添加提示添加即可。

    4配置插件入口类

    紧接着新建一个类,此类必须继承IXposedHookLoadPackage,新建完成后需要对这个类进行配置。

    配置如下:

    新建文件夹命名assets,在文件夹中新建文件xposed_init,指定刚刚编写的模块路径:包名+类名,如下图所示。

    1c25ab4f08766752074c8e566cfdb6c0.png

    5书写代码进行hook

    1.安装目标apk,要求输入账号和注册码,如下图所示。

    0416fe3ed677a1b53ed034bd03ff389b.png

    点击注册后会提示注册失败,那么hook的目的就是让它返回正确。

    (1)打开jadx工具分析源码,最终找到返回值的地方,如下图所示。

    bd5d78d3443e33cd58a14f21c411058a.png

    (2)找到最终判断的地方,书写hook代码,如下图所示。

    a99385e1854835724fc5dba76783e09f.png

    3075b36354448f7edbc638e24cbc8db8.png

    2.运行程序查看最终效果,如下图所示。

    ed02d4c9c5bc5be6be49c4d11a1870c0.png

    2

    小结

    今天学习xposed框架的概念以及如何安装,安装完成后需要使用的功能介绍。以及学习插件的介绍以及基本属性,实战操作编写插件和步骤,运行app达到最终的目的。

    往期精彩回顾

    HOOK startActivity

    HOOK框架-动态代理

    HOOK框架-静态代理

    87fb5c55a731ec12b54e8515a03d4746.png

    展开全文
  • Android之Xposed框架完全使用指南

    千次阅读 2021-10-17 19:38:23
    文章目录Xposed环境搭建Xposed简介Xposed原理Xposed的安装Xposed插件开发Xposed插件编写流程Xposed开发之Hook构造函数相关API无参构造函数的hook有参构造函数的hook实际效果Xposed开发之修改属性相关API修改静态字段...

    Xposed环境搭建

    Xposed简介

    Xposed是一款可以在不修改APK的情况下影响程序运行的框架,基于它可以制作出许多功能强大的模块,且在功能不冲突的情况下同时运作。在这个框架下,我们可以编写并加载自己编写的插件APP,实现对目标apk的注入拦截等。

    Xposed原理

    控制zygote进程,通过替换/system/bin/app_precess程序控制zygote进程,使得它在系统启动的时候会加载Xposed framework的一个jar文件即XposedBridge.jar,从而完成对zygote进程及其创建的Dalvik/ART虚拟机的劫持,并且能够允许开发者独立的替代任何class。

    Xposed的安装

    4.4以下的Android版本安装较为简单,只需要两步:

    1. 对需要安装xposed的手机进行root
    2. 下载并安装xposedinstall,之后授予root权限,进入app点击安装即可

    从Android 5.0开始,谷歌使用ART替换Dalvik,所以Xposed安装有点麻烦,分为两个部分:xposed*.zip和XposedInstaller.apk。zip文件是框架主体,需要进入Recovery后刷入,apk文件是xposed模块管理应用的,主要用于下载,激活,是否启用模块等功能管理。步骤如下:

    1. 完成对手机的root,并刷入recovery(比如twrp)
    2. 下载对应的zip补丁包,进入recovery刷入
    3. 重启手机,安装XposedInstaller并授予root权限即可

    实际操作如下:

    http://dl-xda.xposed.info/framework/
    

    在这里插入图片描述

    首先去官网下载对应的补丁包,sdk23对应Android 6.0版本,其他对应版本请自行查询,我这里用的是6.0的系统

    在这里插入图片描述

    然后选择对应的系统架构

    在这里插入图片描述

    版本选择最新版,接着按照上面的步骤安装xposed模块即可。

    Xposed插件开发

    Xposed插件编写流程

    1. 拷贝XposedBridgeApi.jar到新建工程的libs目录并导入模块

    在这里插入图片描述

    将jar包导入到模块,并设置Configuration为compileOnly

    在这里插入图片描述

    1. 在AndroidMainfest.xml中增加Xposed相关内容
    //是否配置为xposed插件 设置为true
    <meta-data android:name="xposedmodule" android:value="true"/>
    //模块名称
    <meta-data android:name="xposeddescription" android:value="模块描述(例如:第一个xposed插件)"/>
    //最低版本号
    <meta-data android:name="xposedminversion"android:value="54"/>
    
    1. 新建hook类,编写hook代码
    package com.example.xposeddemo01;
    
    import de.robv.android.xposed.IXposedHookLoadPackage;
    import de.robv.android.xposed.callbacks.XC_LoadPackage;
    
    public class Xposed01 implements IXposedHookLoadPackage {
        @Override
        public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
            
        }
    }
    

    实现IXposedHookLoadPackage接口,然后在handleLoadPackage函数内编写Hook代码

    1. 新建assets文件夹,然后在assets目录下新建xposed_init,在里面写上hook类的完整路径(包名+类名),可以有多个,每一个类写一行

    在这里插入图片描述

    Xposed开发之Hook构造函数

    相关API

    需要用到的API如下:

    XposedHelpers.findAndHookConstructor
    

    无参构造函数的hook

    首先编写一个目标hook类,类代码包含多个构造函数

    package com.example.hookdemo01;
    
    public class Student {
            String name;
            String id;
            int age;
        public Student(){
            name="default";
            id="default";
        }
    
        public Student(String name) {
            this.name = name;
        }
        public Student(String name, String id) {
            this.name = name;
            this.id = id;
        }
    
        public Student(String name, String id, int age) {
            this.name = name;
            this.id = id;
            this.age = age;
        }
    }
    
    

    然后打印出类的信息

    package com.example.hookdemo01;
    
    import androidx.appcompat.app.AppCompatActivity;
    
    import android.os.Bundle;
    import android.util.Log;
    
    public class MainActivity extends AppCompatActivity {
    
    
        public void PrintStudent(Student stu)
        {
            Log.i("Xposed",stu.name+"--"+stu.id+"--"+stu.age);
        }
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            Student studenta=new Student();
            Student studentb=new Student("GuiShou");
            Student studentc=new Student("GuiShou2","2021");
            Student studentd=new Student("GuiShou3","2021",20);
    
            PrintStudent(studenta);
            PrintStudent(studentb);
            PrintStudent(studentc);
            PrintStudent(studentd);
    
        }
    }
    

    接着编写hook代码,代码实现写在handleLoadPackage里

     //判断包名是否是要hook的包
            if (loadPackageParam.packageName.equals("com.example.hookdemo01"))
            {
                //获取当前的classloader
                ClassLoader classLoader=loadPackageParam.classLoader;
    
                //获取当前的Class
                Class studentClass=classLoader.loadClass("com.example.hookdemo01.Student");
    
                //hook无参构造函数 参数列表为空 第二个参数类型不需要传入
                XposedHelpers.findAndHookConstructor(studentClass, new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param);
    
                        XposedBridge.log("com.example.hookdemo01.Student() is called! beforeHookedMethod");
    
                    }
    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.example.hookdemo01.Student() is called! afterHookedMethod");
    
                    }
                });
    
    

    有参构造函数的hook

    然后编写有参函数的hook代码

     //hook一个参数的构造函数 传入参数类型
                XposedHelpers.findAndHookConstructor(studentClass,String.class ,new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param);
    
                        //获取参数数组
                        Object[] argsarray=param.args;
                        String name=(String)argsarray[0];
                        //打印参数名
                        XposedBridge.log("com.example.hookdemo01.Student(String) is called! beforeHookedMethod--"+name);
    
                    }
    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.example.hookdemo01.Student(String) is called! afterHookedMethod");
    
                    }
                });
    
    
                //hook两个参数的构造函数 传入参数类型
                XposedHelpers.findAndHookConstructor(studentClass,String.class ,String.class,new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param);
    
                        //获取参数数组
                        Object[] argsarray=param.args;
                        String name=(String)argsarray[0];
                        String id=(String)argsarray[1];
                        //打印参数名
                        XposedBridge.log("com.example.hookdemo01.Student(String,String) is called! beforeHookedMethod--"+name+"--"+id);
    
                    }
    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.example.hookdemo01.Student(String,String) is called! afterHookedMethod");
    
                    }
                });
    
    
                //hook三个参数的构造函数 传入参数类型
                XposedHelpers.findAndHookConstructor(studentClass,String.class ,String.class,int.class,new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param);
    
                        //获取参数数组
                        Object[] argsarray=param.args;
                        String name=(String)argsarray[0];
                        String id=(String)argsarray[1];
                        int age=(int)argsarray[2];
    
                        //打印参数名
                        XposedBridge.log("com.example.hookdemo01.Student(String,String,int) is called! beforeHookedMethod--"+name+"--"+id+"--"+age);
    
                    }
    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.example.hookdemo01.Student(String,String,int) is called! afterHookedMethod");
    
                    }
                });
    

    这里只需要调用findAndHookConstructor函数,完成回调函数编写即可

    实际效果

    启用xposed模块,重启目标app

    在这里插入图片描述

    可以看到这里打印出了所有相关的信息,如果需要还可以对参数进行修改

    Xposed开发之修改属性

    相关API

    需要用到的API如下:

    XposedHelpers.getStaticObjectField
    XposedHelpers.setStaticObjectField
    XposedHelpers.getObjectField
    XposedHelpers.setObjectField
    

    Xposed不只是可以实现对app自己实现的类构造函数的hook,对于类的属性字段也提供了一系列修改的API,首先修改目标类代码

    package com.example.hookdemo01;
    import android.util.Log;
    
    public class Student {
            String name;
            String id;
            int age;
            private String nickname;
            public static String teachername;
            
        public Student(String name, String id, int age, String teacher,String nickname) {
            this.name = name;
            this.id = id;
            this.age = age;
            this.nickname = nickname;
            teachername=teacher;
    
            Log.i("Xposed","构造函数--teachername:"+teachername);
            Log.i("Xposed","构造函数--nickname:"+nickname);
    
        }
    }
    
    

    接着编写hook代码

    修改静态字段和成员字段

    package com.example.xposeddemo01;
    import java.lang.reflect.Field;
    import de.robv.android.xposed.IXposedHookLoadPackage;
    import de.robv.android.xposed.XC_MethodHook;
    import de.robv.android.xposed.XposedBridge;
    import de.robv.android.xposed.XposedHelpers;
    import de.robv.android.xposed.callbacks.XC_LoadPackage;
    
    public class Xposed01 implements IXposedHookLoadPackage {
        @Override
        public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
            //判断包名是否是要hook的包
            if (loadPackageParam.packageName.equals("com.example.hookdemo01"))
            {
                //获取当前的classloader
                ClassLoader classLoader=loadPackageParam.classLoader;
    
                //获取当前的Class
                Class studentClass=classLoader.loadClass("com.example.hookdemo01.Student");
    
                //hook三个参数的构造函数 传入参数类型
                XposedHelpers.findAndHookConstructor(studentClass,String.class ,String.class,int.class,String.class,String.class,new XC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.example.hookdemo01.Student(String,String,int) is called! afterHookedMethod");
    
                        //------------------------修改static属性-------------------------------------
                        //设置teacher字段
                        XposedHelpers.setStaticObjectField(studentClass,"teachername","teacher888");
    
                        //获取teacher字段 打印输出
                        String teacher = (String)XposedHelpers.getStaticObjectField(studentClass,"teachername");
                        XposedBridge.log("修改后的teachername字段:"+teacher);
    
                        //-------------------修改对象属性-----------------------------------------
                       XposedHelpers.setObjectField(param.thisObject,"nickname","pandan888");
    
                        //获取nickname字段 打印输出
                        String nickname=(String)XposedHelpers.getObjectField(param.thisObject,"nickname");
                        XposedBridge.log("修改后的nickname字段:"+nickname);
                    }
                });
    
            }
        }
    }
    
    

    对于修改静态字段和成员字段,需要使用不同的API,xposed类内部已经取消了字段的访问检查,所以不需要自己取消检查,比反射修改字段的方案更加简洁

    实际效果

    在这里插入图片描述

    Xposed开发之hook一般函数

    相关API

    XposedHelpers.findAndHookMethod
    

    hook一般函数

    首先修改一下目标app的代码

       public static String publicstaticfun(String arg1,int arg2)
        {
            //String result= privatestaticfun("test2",200);
            return arg1+"---"+arg2;
        }
    

    增加一个静态的成员函数,接着编写hook代码

    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
            if (loadPackageParam.packageName.equals("com.example.hookdemo01"))
            {
                //获取当前的classloader
                ClassLoader classLoader=loadPackageParam.classLoader;
    
                //获取当前的Class
                Class studentClass=classLoader.loadClass("com.example.hookdemo01.Student");
    
                //hook
                XposedHelpers.findAndHookMethod(studentClass, "publicstaticfun", String.class, int.class, new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param);
    
                        //打印参数
                        Object[] objectarray=param.args;
                        String arg0=(String)objectarray[0];
                        int arg1=(int)objectarray[1];
                        XposedBridge.log("beforeHookedMethod---arg0:"+objectarray[0]+"arg1:"+objectarray[1]);
    
                        //修改参数
                        objectarray[0]="GuiShou";
                        objectarray[1]=888;
                        XposedBridge.log("beforeHookedMethod---arg0:"+objectarray[0]+"arg1:"+objectarray[1]);
    
    
                    }
    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
    
                        //打印返回值
                        String result=(String)param.getResult();
                        XposedBridge.log("afterHookedMethod---result:"+result);
    
                        //修改返回值
                        param.setResult("this it result");
                        String result2=(String)param.getResult();
                        XposedBridge.log("afterHookedMethod---result:"+result2);
    
                    }
                });
            }
        }
    

    实际效果

    在这里插入图片描述

    可以看到,这里已经打印出了修改前后的参数和返回值。实际上,类中的其他函数,例如私有成员函数,匿名内部类函数等等,都是用同样的方法进行hook,只要填入jadx反编译的类名和函数名即可。

    Xposed开发之主动调用函数

     public static String publicstaticfun(String arg1,int arg2)
        {
            Log.i("xposed","publicstaticfun is call");
            return arg1+"---"+arg2;
        }
    
        private String privatefun(String arg1,int arg2)
        {
            Log.i("xposed","privatefun is call");
            return arg1+"---"+arg2;
        }
    

    首先修改代码,增加一个静态函数和一个成员函数,调用时触发log信息

    相关API

    XposedHelpers.callStaticMethod()
    XposedHelpers.callMethod()
    

    调用静态函数

    	//获取当前的classloader
    	ClassLoader classLoader=loadPackageParam.classLoader;
    
    	//获取当前的Class
    	Class studentClass=classLoader.loadClass("com.example.hookdemo01.Student");
    
    	//调用静态函数
    	XposedHelpers.callStaticMethod(studentClass,"publicstaticfun","guishou",100);
    

    调用成员函数

                //获取当前的classloader
                ClassLoader classLoader=loadPackageParam.classLoader;
    
                //获取当前的Class
                Class studentClass=classLoader.loadClass("com.example.hookdemo01.Student");
    
                //调用构造函数 获取对象
                Object obj = XposedHelpers.newInstance(studentClass,"GuiShou3","2021",20,"teacher666","pandan666");
    
                //调用成员函数
                XposedHelpers.callMethod(obj,"privatefun","guishou",100);
    

    实际效果

    在这里插入图片描述

    可以看到,静态函数和成员函数均被调用了。对于类中的静态函数,直接调用即可;对于成员函数,需要先得到类的实例,然后才能完成调用。

    Xposed开发之加壳APP处理

    对于加壳app的hook处理,实际上就是解决ClassLoader的问题。

    对于加壳的APP,如果我们直接去hook当前的apk的话,那么壳代码中的ClassLoder必定是没有我们所需要hook的目标类。

    由于壳代码的ClassLoader中并没有我们需要的类,所以在编写hook代码之前还需要一个步骤,就是在壳代码的修正ClassLoader之后,利用反射的方式拿到修正后的ClassLoader,然后传入修正后的ClassLoader,再对目标类进行hook

    实际代码如下:

     public static Field getClassField(ClassLoader classloader, String class_name,
                                          String filedName) {
    
            try {
                Class obj_class = classloader.loadClass(class_name);//Class.forName(class_name);
                Field field = obj_class.getDeclaredField(filedName);
                field.setAccessible(true);
                return field;
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
    
        }
    
        public static Object getClassFieldObject(ClassLoader classloader, String class_name, Object obj,
                                                 String filedName) {
    
            try {
                Class obj_class = classloader.loadClass(class_name);//Class.forName(class_name);
                Field field = obj_class.getDeclaredField(filedName);
                field.setAccessible(true);
                Object result = null;
                result = field.get(obj);
                return result;
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
    
        }
    
        public static Object invokeStaticMethod(String class_name,
                                                String method_name, Class[] pareTyple, Object[] pareVaules) {
    
            try {
                Class obj_class = Class.forName(class_name);
                Method method = obj_class.getMethod(method_name, pareTyple);
                return method.invoke(null, pareVaules);
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
    
        }
    
        public static Object getFieldOjbect(String class_name, Object obj,
                                            String filedName) {
            try {
                Class obj_class = Class.forName(class_name);
                Field field = obj_class.getDeclaredField(filedName);
                field.setAccessible(true);
                return field.get(obj);
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NullPointerException e) {
                e.printStackTrace();
            }
            return null;
    
        }
    
        public static ClassLoader getClassloader() {
            ClassLoader resultClassloader = null;
            Object currentActivityThread = invokeStaticMethod(
                    "android.app.ActivityThread", "currentActivityThread",
                    new Class[]{}, new Object[]{});
            Object mBoundApplication = getFieldOjbect(
                    "android.app.ActivityThread", currentActivityThread,
                    "mBoundApplication");
            Application mInitialApplication = (Application) getFieldOjbect("android.app.ActivityThread",
                    currentActivityThread, "mInitialApplication");
            Object loadedApkInfo = getFieldOjbect(
                    "android.app.ActivityThread$AppBindData",
                    mBoundApplication, "info");
            Application mApplication = (Application) getFieldOjbect("android.app.LoadedApk", loadedApkInfo, "mApplication");
            resultClassloader = mApplication.getClassLoader();
            return resultClassloader;
        }
    

    调用代码中的getClassloader函数,即可获取到修正后的classloader,接着编写hook代码

        @Override
        public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
    
            if (loadPackageParam.packageName.equals("com.kanxue.xposedhook01")) {
                
                //对壳入口类的onCreate函数进行hook 拿到classloader
                XposedHelpers.findAndHookMethod("com.stub.StubApp", loadPackageParam.classLoader, "onCreate", new XC_MethodHook() {
                    
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        XposedBridge.log("com.stub.StubApp->onCreate afterHookedMethod");
    
                        ClassLoader finalClassLoader=getClassloader();
                        XposedBridge.log("finalClassLoader->" + finalClassLoader);
                        GetClassLoaderClasslist(finalClassLoader);
                        
                        //再对目标类进行hook 传入拿到的classloader
                        XposedHelpers.findAndHookMethod("com.kanxue.xposedhook01.Student", finalClassLoader, "privatefunc", String.class, int.class, new XC_MethodHook() {
                            @Override
                            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                                super.beforeHookedMethod(param);
                                Object[] objectarray = param.args;
                                String arg0 = (String) objectarray[0];
                                int arg1 = (int) objectarray[1];
                                XposedBridge.log("beforeHookedMethod11 privatefunc->arg0:" + arg0 + "---arg1:" + arg1);
    
                            }
    
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                super.afterHookedMethod(param);
    
                                String result = (String) param.getResult();
                                XposedBridge.log("afterHookedMethod11 privatefunc->result:" + result);
    
                            }
                        });
    
                        Class personClass = XposedHelpers.findClass("com.kanxue.xposedhook01.Student$person", finalClassLoader);
                        XposedHelpers.findAndHookMethod(personClass, "getpersonname", String.class, new XC_MethodHook() {
                            @Override
                            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                                super.beforeHookedMethod(param);
                                XposedBridge.log("beforeHookedMethod getpersonname->" + param.args[0]);
                            }
    
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                super.afterHookedMethod(param);
                                XposedBridge.log("afterHookedMethod getpersonname->" + param.getResult());
                            }
                        });
    
    
                    }
                });
    
            }
        }
    
    

    首先需要hook入口类中的onCreate函数,在onCreate函数执行完成之后,获取到修正后的ClassLoader,接着再对目标类进行hook,此时hook的代码和hook一般函数一样,区别在于需要传入修正后的ClassLoder

    实际效果

    在这里插入图片描述

    实际效果如图:可以看到这里已经成功对目标函数进行hook,打印出了hook之前和之后的函数相关信息。

    Xposed指纹检测

    可以根据下面的特征对xposed框架进行检测

    1. xposed插件的管理:XposedInstaller
    2. xposed对函数hook的根本原理:java函数变为native函数
    3. xposed框架拥有大量的api
    4. xposed框架特定的文件:运行库文件和链接库

    github上检测Xposed的demo:XposedChecker

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,924
精华内容 1,969
关键字:

xposed框架