Xposed注入实现分析及免重启定制

最新推荐文章于 2022-08-08 00:29:27 发布
最新推荐文章于 2022-08-08 00:29:27 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： # Android Security Android Hook XPosed 文章标签： android security xposed android hook 免重启

Xposed的实现解析

Xposed简介

Xposed已经作为Android的Java层Hook大哥好多年了，不仅仅是安全研究者和逆向工程师手中的神器，还拥有着很多的插件开发者，在官方仓库收录的插件也已经超过了1000+个，而其服务的用户以各搞机论坛用户为主，也是不尽其数。
Xposed的代码是完全开源的，并且代码量也不算很大，对于安全研究者来说呢，我觉得研究一下Xposed的原理还是很有必要的。
Xposed的github地址：
https://github.com/rovo89/Xposed
https://github.com/rovo89/XposedBridge

 

本文使用Android4.4的源码进行分析

如何实现全局注入

简单的讲，Xposed是通过替换修改过的app_process来注入Zygote以实现的全局注入。

Android的启动过程

想要知道Xposed是如何实现的全局注入，首先要分析一下Android系统的启动过程，就可以很方便的理解Xposed选择的注入点。
我画了张图，Android系统的启动大致如下：
Android系统启动流程
从图中可以很方便的理解从BootLoader到显示系统界面的过程。

应用孵化器 - Zygote

Zygote介绍

Zygote，中文是"受精卵"...实际上他就是一个孵化器，所有应用程序的进程都是由它fork出来的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME
root       155    1      509740  41876  ffffffff b75761e0 S zygote
drm        156    1      18508   4064   ffffffff b7599ff6 S  / system / bin / drmserver
media      157    1      69296   15656  ffffffff b755bff6 S  / system / bin / mediaserver
install    158    1      6580    1228   c04d1048 b7507bb6 S  / system / bin / installd
keystore   159    1      10172   2088   c03f4a25 b7561ff6 S  / system / bin / keystore
root       160    1      1096    4      c044881c  080ddd03  S  / system / xbin / su
system     187    1      81040   3860   ffffffff b75b0ff6 S  / system / bin / surfaceflinger
root       343    2      0       0      c01cfbd5  00000000  S flush - 8 : 16
root       414    62     6732    1412   c02f4452 b74c6bb6 S  / system / bin / sh
root       418    62     6688    1464   c01c0a90 b752e1e0 S logcat
system     424    155    629276  46384  ffffffff b7575ff6 S system_server
u0_a44     506    155    564252  75032  ffffffff b75779eb S com.android.systemui
u0_a0      551    155    525484  25696  ffffffff b75779eb S android.process.acore
wifi       565    1      10776   2912   c01c0a90 b741d1e0 S  / system / bin / wpa_supplicant
system     566    155    526468  21732  ffffffff b75779eb S com.android.settings
u0_a22     606    155    521276  24932  ffffffff b75779eb S com.android.inputmethod.latin
radio      623    155    539356  28428  ffffffff b75779eb S com.android.phone
u0_a23     637    155    557680  45252  ffffffff b75779eb S com.android.launcher
u0_a29     673    155    520300  20324  ffffffff b75779eb S com.android.music
u0_a16     693    155    521532  25876  ffffffff b75779eb S android.process.media
u0_a49     719    155    517580  18600  ffffffff b75779eb S com.android.smspush
u0_a15     806    155    521632  19920  ffffffff b75779eb S com.android.dialer
bluetooth  821    155    522828  22284  ffffffff b75779eb S com.android.bluetooth
dhcp       845    1      6656    1452   c01c0a90 b74e6ab6 S  / system / bin / dhcpcd
u0_a6      916    155    527828  22036  ffffffff b75779eb S com.android.calendar
u0_a7      943    155    519636  23176  ffffffff b75779eb S com.android.providers.calendar
u0_a12     967    155    521156  21960  ffffffff b75779eb S com.android.deskclock
u0_a17     1019   155    528300  24912  ffffffff b75779eb S com.android.email
u0_a18     1078   155    524976  20436  ffffffff b75779eb S com.android.exchange
u0_a28     1168   155    530852  23100  ffffffff b75779eb S com.android.mms
u0_a32     1215   155    517576  19140  ffffffff b75779eb S com.android.onetimeinitializer
u0_a47     1251   155    517732  19072  ffffffff b75779eb S com.android.voicedialer

可以看到，这些包名格式的进程的PPID(父进程PID)都是155，即zygote进程。
Zygote启动之后会建立一个Socket Server，然后fork自身成为一个新的进程——system_server，并让它成为"前端代言人"，当system_server接收到打开进程的请求时，它就会通过Socket跟Zygote通讯，Zygote就再fork自身称为新的进程。

Zygote的启动

在init.rc中可以看到，Zygote是通过app_process启动的，

1
service zygote  / system / bin / app_process  - Xzygote  / system / bin  - - zygote  - - start - system - server

这时app_process的任务也很简单，就是把自己的进程名变成Zygote，然后反射调用Zygote的主方法，即com.android.internal.os.ZygoteInit的main()。之后Zygote做的事情就是在介绍中说过的了。

Hook Zygote

那么Xposed就是通过修改app_process的方式来实现注入Zygote的。
项目地址：https://github.com/rovo89/Xposed 即是修改app_process的源码，在app_main.cpp的main函数中可以看到

1
2
3
4
5
6
7
8
9
10
11
12
isXposedLoaded  =  xposed::initialize(zygote, startSystemServer, className, argc, argv);
if  (zygote) {
     runtime.start(isXposedLoaded ? XPOSED_CLASS_DOTS_ZYGOTE :  "com.android.internal.os.ZygoteInit" ,
             startSystemServer ?  "start-system-server"  : "");
}  else  if  (className) {
     / /  Remainder of args get passed to startup  class  main()
     runtime.mClassName  =  className;
     runtime.mArgC  =  argc  -  i;
     runtime.mArgV  =  argv  +  i;
     runtime.start(isXposedLoaded ? XPOSED_CLASS_DOTS_TOOLS :  "com.android.internal.os.RuntimeInit" ,
             application ?  "application"  :  "tool" );
}

可以看到，Xposed首先尝试加载自己的库，如果成功的话，就将runtime.start的类名替换成自己的类：de.robv.android.xposed.XposedBridge，因为app_processs是采用反射main()的方法来调用加载方法，所以只要在这个类中定义一个main()方法，就可以为所欲为了，最后只需在末尾调用一下com.android.internal.os.ZygoteInit的main()让系统继续跑下去就可以实现对Zygote的Hook。

注入应用进程

既然已经拿到了Zygote的所有权了，但是现在Application还没跑起来呢，如果这个时候就执行Hook模块，肯定是无法Hook到相关代码的。那么这时候就有必要提一下从Zygote接受到请求之后做了什么，我又简单的画了张图:

值得注意的是，因为fork之后的子进程是会继承父进程的状态继续往下跑，所以到handleChildProc的时候，此时已经是子进程在执行程序了，而ActivityThread也是在新进程中loop。
在Activity的loop中，可以接收的消息也包括了Appcalition的生命周期BIND_APPLICATION和EXIT_APPLICATION。处理BIND_APPLICATION的时候是直接调用了handleBindApplication方法，Xposed便是在Zygote中Hook了这个方法，在这里面执行用户的Hook模块，因为在这个时候，已经可以拿到应用的classLoader了，然后将此classLoader封装成一个LoadPackageParam再传给各个模块的handleLoadPackage即可。
在XposedBridge的main中可看到其调用了initForZygote()

1
2
3
4
5
6
7
8
protected static void main(String[] args) {
     ...
         if  (isZygote) {
             XposedInit.hookResources();
             XposedInit.initForZygote();
         }
     ...
}

initForZygote中又Hook了handleBindApplication

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
static void initForZygote() throws Throwable {
     ...
     findAndHookMethod(ActivityThread. class ,  "handleBindApplication" ,  "android.app.ActivityThread.AppBindData" , new XC_MethodHook() {
         @Override
         protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
             ActivityThread activityThread  =  (ActivityThread) param.thisObject;
             ApplicationInfo appInfo  =  (ApplicationInfo) getObjectField(param.args[ 0 ],  "appInfo" );
             String reportedPackageName  =  appInfo.packageName.equals( "android" ) ?  "system"  : appInfo.packageName;
             SELinuxHelper.initForProcess(reportedPackageName);
             ComponentName instrumentationName  =  (ComponentName) getObjectField(param.args[ 0 ],  "instrumentationName" );
             if  (instrumentationName ! =  null) {
                 Log.w(TAG,  "Instrumentation detected, disabling framework for "  +  reportedPackageName);
                 XposedBridge.disableHooks  =  true;
                 return ;
             }
             CompatibilityInfo compatInfo  =  (CompatibilityInfo) getObjectField(param.args[ 0 ],  "compatInfo" );
             if  (appInfo.sourceDir  = =  null)
                 return ;
 
             setObjectField(activityThread,  "mBoundApplication" , param.args[ 0 ]);
             loadedPackagesInProcess.add(reportedPackageName);
             LoadedApk loadedApk  =  activityThread.getPackageInfoNoCheck(appInfo, compatInfo);
             XResources.setPackageNameForResDir(appInfo.packageName, loadedApk.getResDir());
 
             XC_LoadPackage.LoadPackageParam lpparam  =  new XC_LoadPackage.LoadPackageParam(XposedBridge.sLoadedPackageCallbacks);
             lpparam.packageName  =  reportedPackageName;
             lpparam.processName  =  (String) getObjectField(param.args[ 0 ],  "processName" );
             lpparam.classLoader  =  loadedApk.getClassLoader();
             lpparam.appInfo  =  appInfo;
             lpparam.isFirstApplication  =  true;
             XC_LoadPackage.callAll(lpparam);
 
             if  (reportedPackageName.equals(INSTALLER_PACKAGE_NAME))
                 hookXposedInstaller(lpparam.classLoader);
         }
     });
     ...
}

Xposed在Zygote进程中执行完这些之后，每次fork出来的都是handleBindApplication已经被Hook过的进程，所以当每个应用进程被打开的时候，都会最开始就先执行Xposed的模块插件，然后才开始执行本身的代码。这样就实现了注入到每个应用程序来进行Hook。

如何实现Hook

findAndHookMethod

findAndHookMethod想必是大家写Xposed插件最常用及最熟悉的一个方法，我们就通过这个方法来分析Xposed是如何实现的Java Hook。

1
2
3
4
5
6
7
8
9
public static XC_MethodHook.Unhook findAndHookMethod(Class<?> clazz, String methodName,  Object ... parameterTypesAndCallback) {
     if  (parameterTypesAndCallback.length  = =  0  || !(parameterTypesAndCallback[parameterTypesAndCallback.length - 1 ] instanceof XC_MethodHook))
         throw new IllegalArgumentException( "no callback defined" );
 
     XC_MethodHook callback  =  (XC_MethodHook) parameterTypesAndCallback[parameterTypesAndCallback.length - 1 ];
     Method m  =  findMethodExact(clazz, methodName, getParameterClasses(clazz.getClassLoader(), parameterTypesAndCallback));
 
     return  XposedBridge.hookMethod(m, callback);
}

大家知道这个方法的参数是个可变长参数列表，然后它会取最后一个参数来作为callback，即hook时的注入的代码。然后通过反射的方法来得到原本的Method。最后将这两个传给hookMethod。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static XC_MethodHook.Unhook hookMethod(Member hookMethod, XC_MethodHook callback) {
     ...
     if  (newMethod) {
         Class<?> declaringClass  =  hookMethod.getDeclaringClass();
         int  slot;
         Class<?>[] parameterTypes;
         Class<?> returnType;
         if  (runtime  = =  RUNTIME_ART) {
             slot  =  0 ;
             parameterTypes  =  null;
             returnType  =  null;
         }  else  if  (hookMethod instanceof Method) {
             slot  =  getIntField(hookMethod,  "slot" );
             parameterTypes  =  ((Method) hookMethod).getParameterTypes();
             returnType  =  ((Method) hookMethod).getReturnType();
         }  else  {
             slot  =  getIntField(hookMethod,  "slot" );
             parameterTypes  =  ((Constructor<?>) hookMethod).getParameterTypes();
             returnType  =  null;
         }
 
         AdditionalHookInfo additionalInfo  =  new AdditionalHookInfo(callbacks, parameterTypes, returnType);
         hookMethodNative(hookMethod, declaringClass, slot, additionalInfo);
     }
     ...
}

可以看到hookMethod实际上时调用了一个native函数hookMethodNative，其他参数都很好理解，但是取的这个slot是个什么东西？翻了一下百度，在Dalvik的源码中dalvik/vm/reflect.c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static  int  methodToSlot(const Method *  meth)
{
     ClassObject *  clazz  =  meth - >clazz;
     int  slot;
 
     if  (dvmIsDirectMethod(meth)) {
         slot  =  meth  -  clazz - >directMethods;
         slot  =  - (slot + 1 );
     }  else  {
         slot  =  meth  -  clazz - >virtualMethods;
     }
 
     return  slot;
}

原来这个slot就是此method在ClassObject的methods中的偏移，directMethods为负，virtualMethods为正。

偷梁换柱

hookMethodNative对应C函数XposedBridge_hookMethodNative

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void XposedBridge_hookMethodNative(JNIEnv *  env, jclass clazz, jobject reflectedMethodIndirect,
             jobject declaredClassIndirect, jint slot, jobject additionalInfoIndirect) {
     / /  Usage errors?
     if  (declaredClassIndirect  = =  NULL || reflectedMethodIndirect  = =  NULL) {
         dvmThrowIllegalArgumentException( "method and declaredClass must not be null" );
         return ;
     }
 
     / /  Find the internal representation of the method
     ClassObject *  declaredClass  =  (ClassObject * ) dvmDecodeIndirectRef(dvmThreadSelf(), declaredClassIndirect);
     Method *  method  =  dvmSlotToMethod(declaredClass, slot);
     if  (method  = =  NULL) {
         dvmThrowNoSuchMethodError( "Could not get internal representation for method" );
         return ;
     }
 
     if  (isMethodHooked(method)) {
         / /  already hooked
         return ;
     }
 
     / /  Save a copy of the original method  and  other hook info
     XposedHookInfo *  hookInfo  =  (XposedHookInfo * ) calloc( 1 , sizeof(XposedHookInfo));
     memcpy(hookInfo, method, sizeof(hookInfo - >originalMethodStruct));
     hookInfo - >reflectedMethod  =  dvmDecodeIndirectRef(dvmThreadSelf(), env - >NewGlobalRef(reflectedMethodIndirect));
     hookInfo - >additionalInfo  =  dvmDecodeIndirectRef(dvmThreadSelf(), env - >NewGlobalRef(additionalInfoIndirect));
 
     / /  Replace method with our own code
     SET_METHOD_FLAG(method, ACC_NATIVE);
     method - >nativeFunc  =  &hookedMethodCallback;
     method - >insns  =  (const u2 * ) hookInfo;
     method - >registersSize  =  method - >insSize;
     method - >outsSize  =  0 ;
 
     if  (PTR_gDvmJit ! =  NULL) {
         / /  reset JIT cache
         char currentValue  =  * ((char * )PTR_gDvmJit  +  MEMBER_OFFSET_VAR(DvmJitGlobals,codeCacheFull));
         if  (currentValue  = =  0  || currentValue  = =  1 ) {
             MEMBER_VAL(PTR_gDvmJit, DvmJitGlobals, codeCacheFull)  =  true;
         }  else  {
             ALOGE( "Unexpected current value for codeCacheFull: %d" , currentValue);
         }
     }
}

首先是通过slot获取到Method对象在内存中的Method结构体指针，然后将它设置为一个native方法，再将他的nativeFunc即执行时对应的函数地址设置为hookedMethodCallback的指针，将保存着原method信息的hookInfo暂时存放在本是dalvik字节码的insns，reflectedMethod是原method的java对象，additionalInfo是AdditionalHookInfo对象。
然后当调用到这个方法的时候，执行的就变成了hookedMethodCallback函数了。

1
2
3
4
5
6
void hookedMethodCallback(const u4 *  args, JValue *  pResult, const Method *  method, ::Thread *  self ) {
     ...
     dvmCallMethod( self , (Method * ) methodXposedBridgeHandleHookedMethod, NULL, &result,
         originalReflected, ( int ) original, additionalInfo, thisObject, argsArray);
     ...
}

主要就是又调了一个java方法methodXposedBridgeHandleHookedMethod，解释一下各个参数，originalReflected就是上面hookInfo的reflectedMethod，original是原method结构体指针，后面的不必解释了吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
private static  Object  handleHookedMethod(Member method,  int  originalMethodId,  Object  additionalInfoObj,
             Object  thisObject,  Object [] args) throws Throwable {
         ...
         int  beforeIdx  =  0 ;
         do {
             try  {
                 ((XC_MethodHook) callbacksSnapshot[beforeIdx]).beforeHookedMethod(param);
             } catch (Throwable t) {
                 XposedBridge.log(t);
 
                 / /  reset result (ignoring what the unexpectedly exiting callback did)
                 param.setResult(null);
                 param.returnEarly  =  false;
                 continue ;
             }
 
             if  (param.returnEarly) {
                 / /  skip remaining  "before"  callbacks  and  corresponding  "after"  callbacks
                 beforeIdx + + ;
                 break ;
             }
         }  while  ( + + beforeIdx < callbacksLength);
 
         / /  call original method  if  not  requested otherwise
         if  (!param.returnEarly) {
             try  {
                 param.setResult(invokeOriginalMethodNative(method, originalMethodId,
                         additionalInfo.parameterTypes, additionalInfo.returnType, param.thisObject, param.args));
             } catch (InvocationTargetException e) {
                 param.setThrowable(e.getCause());
             }
         }
 
         / /  call  "after method"  callbacks
         int  afterIdx  =  beforeIdx  -  1 ;
         do {
             Object  lastResult  =   param.getResult();
             Throwable lastThrowable  =  param.getThrowable();
 
             try  {
                 ((XC_MethodHook) callbacksSnapshot[afterIdx]).afterHookedMethod(param);
             } catch (Throwable t) {
                 XposedBridge.log(t);
 
                 / /  reset to last result (ignoring what the unexpectedly exiting callback did)
                 if  (lastThrowable  = =  null)
                     param.setResult(lastResult);
                 else
                     param.setThrowable(lastThrowable);
             }
         }  while  ( - - afterIdx > =  0 );
     ...
}

那么methodXposedBridgeHandleHookedMethod做的事情也很好理解，就是先把所有的beforeHookedMethod给调用一遍，然后再还原原来的method调用一遍，最后再把所有的afterHookMethod的给调用一遍，就完成了。

还原执行

执行原来的方法调用的是native方法invokeOriginalMethodNative。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void XposedBridge_invokeOriginalMethodNative(const u4 *  args, JValue *  pResult,
             const Method *  method, ::Thread *  self ) {
     Method *  meth  =  (Method * ) args[ 1 ];
     if  (meth  = =  NULL) {
         meth  =  dvmGetMethodFromReflectObj(( Object * ) args[ 0 ]);
         if  (isMethodHooked(meth)) {
             meth  =  (Method * ) meth - >insns;
         }
     }
     ArrayObject *  params  =  (ArrayObject * ) args[ 2 ];
     ClassObject *  returnType  =  (ClassObject * ) args[ 3 ];
     Object *  thisObject  =  ( Object * ) args[ 4 ];  / /  null  for  static methods
     ArrayObject *  argList  =  (ArrayObject * ) args[ 5 ];
 
     / /  invoke the method
     pResult - >l  =  dvmInvokeMethod(thisObject, meth, argList, params, returnType, true);
     return ;
}

emm..就是通过拿到备份的method结构体，然后直接调用dvmInvokeMethod即可。

改造更新免重启的Xposed

大家在写Xposed模块的时候是不是有一个很不爽的地方，就是每次改两行代码之后又得重启，非常的烦，那么清楚了注入的原理之后，发现这点好像不是必须的！只是rovo89可能是考虑到性能的问题，所以才采用这种方案。实际上，只要轻轻的改动两行代码，就可以实现免重启更新！

Xposed原加载机制

Xposed原本是在app_process的时候一次性将模块列表读取，Load之后将其hook类放到一个Set里面，在de.robv.android.xposed.XposedBridge的main()中可以看到

1
2
3
4
5
6
7
8
9
10
protected static void main(String[] args) {
     ...
         if  (isZygote) {
             XposedInit.hookResources();
             XposedInit.initForZygote();
         }
 
         XposedInit.loadModules();
     ...
}

待到应用启动的时候再分别调用每个handleLoadPackage，之后就不再读取插件。因为这样，所以每次fork之后，插件已经被加载在内存中了，就算更新插件也不会被读取加载，所以必须得重启才能使得插件生效。

处理办法

之前说到，Xposed通过HookhandleBindApplication来进入每个应用进程，那只要在这个时候再loadModules，那不就ojbk了吗？
在loadModule中，进行加载不仅有handleLoadPackage，还有hook资源及hook命令行程序的包，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private static void loadModule(String apk, ClassLoader topClassLoader) {
         ...
                         if  (moduleInstance instanceof IXposedHookZygoteInit) {
                             IXposedHookZygoteInit.StartupParam param  =  new IXposedHookZygoteInit.StartupParam();
                             param.modulePath  =  apk;
                             param.startsSystemServer  =  startsSystemServer;
                             ((IXposedHookZygoteInit) moduleInstance).initZygote(param);
                         }
                         if  (moduleInstance instanceof IXposedHookLoadPackage)
                             XposedBridge.hookLoadPackage(new IXposedHookLoadPackage.Wrapper((IXposedHookLoadPackage) moduleInstance));
                         if  (moduleInstance instanceof IXposedHookInitPackageResources)
                             XposedBridge.hookInitPackageResources(new IXposedHookInitPackageResources.Wrapper((IXposedHookInitPackageResources) moduleInstance));
                     }  else  {
                         if  (moduleInstance instanceof IXposedHookCmdInit) {
                             IXposedHookCmdInit.StartupParam param  =  new IXposedHookCmdInit.StartupParam();
                             param.modulePath  =  apk;
                             param.startClassName  =  startClassName;
                             ((IXposedHookCmdInit) moduleInstance).initCmdApp(param);
         ...
     }

但是我的需求就是只需要处理handleLoadPackage就可以了，所以给这个参数加个开关isLoadHookLoadPackage，我的代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
if  (XposedBridge.isZygote) {
         if  (moduleInstance instanceof IXposedHookZygoteInit) {
             IXposedHookZygoteInit.StartupParam param  =  new IXposedHookZygoteInit.StartupParam();
             param.modulePath  =  apk;
             param.startsSystemServer  =  startsSystemServer;
             ((IXposedHookZygoteInit) moduleInstance).initZygote(param);
         }
 
         if  (moduleInstance instanceof IXposedHookLoadPackage)
             if (isLoadHookLoadPackage)
             {
                 XposedBridge.hookLoadPackage(new IXposedHookLoadPackage.Wrapper((IXposedHookLoadPackage) moduleInstance));
             }
         if  (moduleInstance instanceof IXposedHookInitPackageResources)
             XposedBridge.hookInitPackageResources(new IXposedHookInitPackageResources.Wrapper((IXposedHookInitPackageResources) moduleInstance));
     }  else  {
         if  (moduleInstance instanceof IXposedHookCmdInit) {
             IXposedHookCmdInit.StartupParam param  =  new IXposedHookCmdInit.StartupParam();
             param.modulePath  =  apk;
             param.startClassName  =  startClassName;
             ((IXposedHookCmdInit) moduleInstance).initCmdApp(param);
         }
     }

实际上就是简单的加了一个if而已，然后在main的地方改成

1
XposedInit.loadModules(false);

最后就是在hook handleBindApplication的地方加上XposedInit.loadModules(true);

1
2
3
4
5
findAndHookMethod(ActivityThread. class ,  "handleBindApplication" ,  "android.app.ActivityThread.AppBindData" , new XC_MethodHook() {
     @Override
     protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
         XposedInit.loadModules(true);
...

嗯，炒鸡简单，改源码不超过2分钟。

编译

改源码两分钟，编译五小时..
rovo89还提供了另外一个项目:https://github.com/rovo89/XposedTools
因为Xposed编译需要依赖AOSP来进行编译，这个工具就是专门用来编译Xposed源码的，使用方法也很简单，填好build.conf然后一把梭就可以了，具体的可以查看百度。

 

需要注意的是，上叙的源码是新版的xposed，就是支持5.0+art的，而我使用的是4.4.4的源码，模拟器也是4.4，所以clone源码的时候要-b master来切换分支。然后修改的代码也大同小异，就是loadmodule多了个startClassName参数，可以通过getStartClassName()方法获取，就是这样：
XposedBridge.loadModules(getStartClassName(),true);
因为这个老工程是个Eclipse工程，XposedTool是依赖于Gradle，所以无法使用XposedTool编译。直接使用Android Studio - Build Apk最后把文件名改成XposedBridge.jar即可，
最后你可以选择直接修改Xposed Installer将其中的XposedBridge.jar替换再安装，或者在手机上安装好Xposed，然后将修改好的XposedBridge.jar替换/data/data/de.robv.android.xposed.installer/bin/XposedBridge.jar，重启，就可以愉快的调插件玩耍了。

 

顺便fork了一份，并把代码上传了，虽说总共也没改几行代码，2333。。

 

5.0- : https://github.com/hluwa/XposedBridge/tree/master

4.4+ : https://github.com/hluwa/XposedBridge/tree/art


原文地址：https://bbs.pediy.com/thread-223713.htm

Omni-Space
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android中利用Xposed框架实现拦截系统方法
09-01
在Android系统中，Xposed框架通过系统进程注入技术，使得开发者能够拦截并修改系统或应用的方法调用，从而实现自定义功能。 ### 前言 1. **Xposed框架介绍**：Xposed框架的核心在于其提供的API，让开发者可以方便...
Xposed资源含安装及卸载文件
07-22
Xposed框架通常包含一个服务应用和一个模块管理界面，通过在系统层注入代码来实现对其他应用的定制。 2. **Xposed框架卸载工具（xposed-uninstaller-20180117-arm64.zip）**：这个文件用于卸载已经安装的Xposed框架...
XposedNoRebootModuleSample 不需要频繁重启调试的Xposed 模块源码例子
weixin_33737134的博客
06-22 279
XposedNoRebootModuleSample（不需要频繁重启调试的Xposed 模块源码例子） Xposed Module Sample No Need To Reboot When Debuggithub:https://github.com/asiontang/XposedNoRebootModuleSample @Override public void h...
xposed android L主题,[原创]Xposed注入实现分析及免重启定制
weixin_31881743的博客
05-26 269
Xposed的实现解析Xposed简介Xposed已经作为Android的Java层Hook大哥好多年了，不仅仅是安全研究者和逆向工程师手中的神器，还拥有着很多的插件开发者，在官方仓库收录的插件也已经超过了1000+个，而其服务的用户以各搞机论坛用户为主，也是不尽其数。Xposed的代码是完全开源的，并且代码量也不算很大，对于安全研究者来说呢，我觉得研究一下Xposed的原理还是很有必要的。Xpo...
android xposed软重启,Xposed注入实现分析及免重启定制
weixin_31463457的博客
05-26 600
Xposed的实现解析Xposed简介Xposed已经作为Android的Java层Hook大哥好多年了，不仅仅是安全研究者和逆向工程师手中的神器，还拥有着很多的插件开发者，在官方仓库收录的插件也已经超过了1000+个，而其服务的用户以各搞机论坛用户为主，也是不尽其数。Xposed的代码是完全开源的，并且代码量也不算很大，对于安全研究者来说呢，我觉得研究一下Xposed的原理还是很有必要的。Xpo...
android xposed软重启,Xposed插件安装更新免重启手机方案
weixin_29128423的博客
05-26 890
但实际情况是，很多开发者只使用了Xposed的一部分功能，也就是de.robv.android.xposed.IXposedHookLoadPackage提供的功能。一般情况下，只是实现了该接口，然后在目标应用程序进程中注入执行插件代码，干一些自定义的勾当。本文提供的免重启方案，仅仅针对de.robv.android.xposed.IXposedHookLoadPackage接口而已。如果你在开发...
Xposed免重启更新模块
weixin_42454310的博客
11-14 680
地址:[Xposed免重启更新模块](https://www.cnblogs.com/CYCLearning/p/11636420.html)
XposedInstaller
01-28
总的来说，XposedInstaller为Android用户提供了一种新的个性化途径，通过它，用户可以探索和实现更多定制化的可能性，同时也要意识到这需要一定的技术知识和谨慎操作。如果你对Android系统有深入的兴趣，并希望挖掘...
xposed x86手架包
09-19
Xposed是由Rovo89开发的一个模块化框架，它在系统层面上注入代码，使用户能够通过安装不同的Xposed模块来改变系统的各个方面，如界面、系统行为、应用功能等。这些模块可以在Google Play商店或者Xposed下载平台上...
xposed-v90-sdk26.zip
07-02
这使得用户能够在不破坏系统保修的情况下实现个性化定制和功能扩展。 在本例中，我们有两个版本的Xposed框架：xposed-v90-sdk26-arm64-beta3.zip和xposed-v90-sdk26-arm-beta3.zip。它们分别适用于基于ARM64架构和...
Xposed的一个Hook模块，用于java加密算法破解.zip
最新发布
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势包括以下几个方面： 跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了代码和底层硬件之间的中介。 面向对象： Java是一种纯粹的面向对象编程语言，支持封装、继承和多态等面向对象的概念。这使得Java编写的代码更加模块化、可维护和可扩展。 多线程支持： Java内置了对多线程的支持，允许程序同时执行多个任务。这对于开发需要高并发性能的应用程序（如服务器端应用、网络应用等）非常重要。 自动内存管理（垃圾回收）： Java具有自动内存管理机制，通过垃圾回收器自动回收不再使用的对象，使得开发者不需要手动管理内存，减轻了程序员的负担，同时也减少了内存泄漏的风险。
Xposed模块开发,免重启改进方案
热门推荐
u011956004的博客
11-23 1万+
Xposed模块开发,免重启技巧工欲善其事,必先利其器.我们在开发Xposed模块的时候,每一次修改Hook方法,都需要重启一次设备,很是麻烦,还浪费了很多宝贵的时间,有没有不重启的办法呢?当然有的,不然我在这里bb什么? 具体实现Android设备安装一个app后，系统会在/data/app/目录下保存一份原始的apk安装包,当我们覆盖安装这个app时,系统同样会删除旧的apk文件,而保留新的
android hook 框架 xposed 如何实现注入
weixin_30929295的博客
02-28 242
Android so注入-libinject2 简介、编译、运行 Android so注入-libinject2 如何实现so注入 Android so注入-Libinject 如何实现so注入 Android so注入挂钩-Adbi 框架简介、编译、运行 Android so注入挂钩-Adbi 框架如何实现so注入 Android so注入挂钩-Adbi 框架如何实现so函数挂钩 ...
Xposed如何植入自己编写的java代码文件或jar库
HURUWO的技术博客
11-02 560
整体步骤如下 1.编写代码编译jar,转换成成dex文件 2.将dex文件放在指定文件目录 3.DexClassLoader 合并 dex文件 4.DexClassLoader 找到新的类并使用 java编写逻辑代码生成jar 简单的代码: package com.test.huruwo; public class Test { public static String test() { return "鎴戞槸琚悎骞剁殑dex"; } } buid生成jar文件 jar
xpose修改手机imei码，注入广告
recall2012的专栏
11-24 3274
何为hook Hook英文翻译过来就是“钩子”的意思，那我们在什么时候使用这个“钩子”呢？我们知道，在Android操作系统中系统维护着自己的一套事件分发机制。应用程序，包括应用触发事件和后台逻辑处理，也是根据事件流程一步步的向下执行。而“钩子”的意思，就是在事件传送到终点前截获并监控事件的传输，像个钩子勾上事件一样。并且能够在勾上事件时，处理一些自己特定的事件。如下图所示：Hook的这个本领，使
android 进程注入 工具,Xposed注入实现分析及免重启定制
weixin_33954023的博客
05-25 815
原标题：Xposed注入实现分析及免重启定制Xposed的实现解析Xposed简介Xposed已经作为Android的Java层Hook大哥好多年了，不仅仅是安全研究者和逆向工程师手中的神器，还拥有着很多的插件开发者，在官方仓库收录的插件也已经超过了1000+个，而其服务的用户以各搞机论坛用户为主，也是不尽其数。Xposed的代码是完全开源的，并且代码量也不算很大，对于安全研究者来说呢，我觉得研究...
android 动态hook,[求助]动态加载的dex中的方法，Xposed如何hook?
weixin_39604983的博客
05-25 589
2016-1-6 10:43原来做过个hook qq动态加载的dexXposedHelpers.findAndHookMethod("com.tencent.mobileqq.app.message.BaseMessageProcessor",lpparam.classLoader, "a", String.class, boolean.class,List.class, boolean.clas...
[免费专栏] Android安全之Android Xposed插件开发，小白都能看得懂的教程
橙留香Park的博客
08-08 8115
转移发布平台通知：将不再在CSDN博客发布新文章，敬请移步知识星球... ...
xposed hook 静态函数_Xposed高级用法 实现Tinker热修复
weixin_39589766的博客
11-24 670
本文为看雪论坛优秀文章看雪论坛作者ID：珍惜AnyHi！大家好，我是珍惜。给大家简单介绍一下，如何用Xposed实现对某个类的替换覆盖。在不编译源码的情况，直接修改原Class内容。(之前的这篇帖子，也不错。Xposed实现Native层Hook：Art 模式 实现Xposed Native注入https://bbs.pediy.com/thread-251171.htm)当我们在 findCla...
深入解析Xposed框架：Android全局hook机制
"Xposed框架分析，hook技术，Android进程，SDK Hook，NDK Hook，全局hook，Xposed原理，Xposed工程" Xposed框架是一种在Android系统上广泛使用的hook框架，它允许开发者通过修改系统行为来实现各种自定义功能，如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值