插件化Hook Activity

作者: xqiiitan | 来源:发表于2024-07-08 16:33 被阅读0次

Android插件化（2）启动未注册的Service
activity插件化hook
11 Activity插件化(Hook)
RePlugin之Activity启动流程
Hook方式实现Activity插件化
Android插件化原理--Hook Activity
Android插件化之Hook Activity
Android-第三方开源框架—插件化原理之Activity插件
Android Hook 技术——反射技术
插件化之旅3-Hook实现加载完整的apk

插件化架构介绍

简介：点击按钮，去服务器下载一个功能.apk, 保存到本地。
它没有运行是单独的plugin，我们要把它启动起来，并给它传递参数。

启动的插件Activity，是没有在主app中注册的。绕过Manifest的检测。
类需要加载，插件的Activity的类是在插件中，
资源需要加载，

2.Hook启动流程 startActivity: 动态代理，下钩子函数。

基于动态代理设计模式，基于Activity启动流程。 IActivityManager
MVP，RXJava 都使用了代理。
用一个注册了的ProxyActivity占坑，让ProxyActivity去过安检。真实的Activity不过安检，后面将intent替换回来。

2.1 获取ActivityManagerNative里面的IActivityManagerSingleton( 旧版本gDefault)
2.2 获取IActivityManagerSingleton( 旧版本gDefault) 中的 IActivityManagerSingleton(旧版本mInstance)属性。
2.3 用一个注册了的ProxyActivity占坑，让ProxyActivity去过安检。
2.4 将intent换回来，换成原来的。
- 2.4.1 获取 ActivityThread 实例；
- 2.4.2 获取 ActivityThread中的mH。
- 2.4.3 hook handleLaunchActivity.

@Hide
public abstract class Singleton<T> {
    @UnsupportedAppUsage
    public Singleton() {
    }
    @UnsupportedAppUsage
    private T mInstance;
    protected abstract T create();
    @UnsupportedAppUsage
    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

// Handler
public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) { // mCallback 非空的情况下。
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

public class BaseApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        HookStartActivityUtil hookUtil = new HookStartActivityUtil(this, ProxyActivity.class);
        try {
            hookUtil.hookStartActivity();
            hookUtil.hookLaunchActivity();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

// 主app中页面，跳转到 插件化未注册的TestActivity。
public void jumpPage(View view) {
    try {
        Intent intent = new Intent();
        intent.setClass(this, Class.forName("com.tom.hook.TestActivity"));
        intent.putExtra("user_name", "zhangSan");
        startActivity(intent);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
   
/**
 * Added by Tom on 2024/07/09.
 * 代理过检测的Activity
 */
public class ProxyActivity extends Activity {
}

package com.tom.hook;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Added by Tom on 2024/07/09.
 */
public class HookStartActivityUtil {
    private static final String TAG = "HookStartActivityUtil";
    private Context mContext;
    private Class<?> mProxyClass; // 用来过安检的类。已经注册过的类。
    private final String EXTRA_ORIGIN_INTENT = "EXTRA_ORIGIN_INTENT";

    public HookStartActivityUtil(Context context, Class<?> proxyClass) {
        this.mContext = context.getApplicationContext();
        this.mProxyClass = proxyClass;
    }

    public void hookStartActivity() throws Exception {
        Object singleTon = null;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            @SuppressLint("PrivateApi")
            Class<?> activityManagerClass = Class.forName("android.app.ActivityTaskManager");
            Field iActivityManagerSingletonField = activityManagerClass.getDeclaredField("IActivityTaskManagerSingleton");
            iActivityManagerSingletonField.setAccessible(true);
            singleTon = iActivityManagerSingletonField.get(null);
            Log.d(TAG, "singleTon:" + singleTon.toString());
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            /*
             * android 26或以上版本的API是一样的
             */
            Class<?> activityManagerClass = Class.forName("android.app.ActivityManager");
            Field iActivityManagerSingletonField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
            iActivityManagerSingletonField.setAccessible(true);
            singleTon = iActivityManagerSingletonField.get(null);
        } else {
            /*
             *  android 26或以下版本的API是一个系列
             */
            Class<?> activityManagerClass = Class.forName("android.app.ActivityManagerNative");
            Field iActivityManagerSingletonField = activityManagerClass.getDeclaredField("gDefault");
            iActivityManagerSingletonField.setAccessible(true);
            singleTon = iActivityManagerSingletonField.get(null);
            // 2.1 获取ActivityManagerNative里面的IActivityManagerSingleton( 旧版本gDefault)
            // 2.2 获取属性: IActivityTaskManagerSingleton(旧版本 gDefault)属性。
        }
        // 2.3 通过gDefault的mInstance属性，获取

        // 而实际上AMS在单例Singleton中
        Class<?> singletonClazz = Class.forName("android.util.Singleton");
        Field mInstanceField = singletonClazz.getDeclaredField("mInstance");
        mInstanceField.setAccessible(true);
        Object iamInstance = mInstanceField.get(singleTon); // AMS
        if (iamInstance == null) Log.e(TAG, "iamInstance is null!!!");

        Class<?> iActivityManagerClass;
        // 因为生成的接口类变了，所以这里我们需要根据版本来代理不同的接口class
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            // android10+ 代理IActivityTaskManager
            iActivityManagerClass = Class.forName("android.app.IActivityTaskManager");
        } else {
            // android10- 代理IActivityManager
            iActivityManagerClass = Class.forName("android.app.IActivityManager");
        }
        iamInstance = Proxy.newProxyInstance(HookStartActivityUtil.class.getClassLoader(),
                new Class[]{iActivityManagerClass},
                // InvocationHandler 执行者，
                new StartActivityInvocationHandler(iamInstance));
        // 4. 重新设定, 重新设定为我们的代理。
        mInstanceField.set(singleTon, iamInstance);
    }

    // 动态代理
    private class StartActivityInvocationHandler implements InvocationHandler {
        // 方法真正的执行者。高版本API中，TODO 拿到的这个值为null。可使用腾讯的Shadow 插件化框架。
        private Object mObject;
        public StartActivityInvocationHandler(Object object) {
            this.mObject = object;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Log.e(TAG, "method: " + method.getName());
            // 替换intent，过AndroidManifest.xml 的检测
            if (method.getName().equals("startActivity")) {
                // 1.获取原来intent替换，最后启动的时候再替换回来。
                Intent originIntent = (Intent) args[2];
                // 2.使用安全的intent替换。去安检。
                Intent safeIntent = new Intent(mContext, mProxyClass);
                args[2] = safeIntent;
                // 3.绑定原来的(缓存原来的Activity)
                safeIntent.putExtra(EXTRA_ORIGIN_INTENT, originIntent);
            }
            return method.invoke(mObject, args);
        }
    }

    // hook handler（ActivityManager.mH）
    public void hookLaunchActivity() throws Exception {
        // 2.4.1 获取 ActivityThread 实例；
        Class<?> atClass = Class.forName("android.app.ActivityThread");
        Field scatField = atClass.getField("sCurrentActivityThread");
        scatField.setAccessible(true);
        Object sCurrentActivityThread = scatField.get(null);

        // 2.4.2 获取  ActivityThread中的mH。
        Field mHField = atClass.getDeclaredField("mH");
        mHField.setAccessible(true);
        Handler mHandler = (Handler) mHField.get(sCurrentActivityThread);

        // 2.4.3 hook  handleLaunchActivity.
        // 给Handler 设置Callback
        Class<?> handlerClass = Class.forName("android.os.Handler");
        Field mCallback = handlerClass.getDeclaredField("mCallback");
        mCallback.setAccessible(true);
        mCallback.set(mHandler, new HandlerCallback());
    }

    private class HandlerCallback implements Handler.Callback {
        @Override
        public boolean handleMessage(Message msg) {
            // 每发一个消息，都会走handleMessage 方法一次。
            if (msg.what == 100) {
                handleLaunchActivity(msg);
            }
            return false;
        }

        // 开始启动创建Activity 拦截，将intent还回去。
        private void handleLaunchActivity(Message msg) {
            try {
                Object record = msg.obj;
                // 1.从record 中拿过安检的intent
                Field intentField = record.getClass().getDeclaredField("intent");
                intentField.setAccessible(true);
                Intent safeIntent = (Intent) intentField.get(record);

                // 2.从safeIntent中， 获取原来的originIntent
                Intent originIntent = safeIntent.getParcelableExtra(EXTRA_ORIGIN_INTENT);
                // 3.重新设置回去intent。
                if (originIntent != null) {
                    intentField.set(record, originIntent);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}

Android插件化（2）启动未注册的Service
在上一篇Activity的插件化已经介绍了Android插件化的概念和通过Hook方案实现Activity的插件化...
activity插件化hook
动态加载：加载已安装和未安装的apk 动态加载技术就是使用类加载器加载相应的apk、dex、jar（必须含有de...
11 Activity插件化(Hook)
RePlugin之Activity启动流程
前面我们了解了RePlugin插件化的基础， Hook 和坑位在使用插件中的Activity时，我们这样做的R...
Hook方式实现Activity插件化
随着应用程序的功能模块越来越多，复杂度越来越高，导致了应用程序模块之间的耦合度越来越高，App的体积也随之越来越大...
Android插件化原理--Hook Activity
项目地址https://github.com/tiann/understand-plugin-framework ...
Android插件化之Hook Activity
插件化：Android插件化技术，可以实现功能模块的按需加载和动态更新（从服务器上下载），其本质是动态加载未安装的...
Android-第三方开源框架—插件化原理之Activity插件
前言四大组件的插件化是插件化技术的核心知识点，而Activity插件化更是重中之重，Activity插件化主要有...
Android Hook 技术——反射技术
概要我们在之前的一篇Android-Framework-Plugin插件话框架-Hook Activity过程 ...
插件化之旅3-Hook实现加载完整的apk
一、插件化与Hook实现集中式登录架构的区别？不同点：目的不同，集中式登录框架是利用Hook实现的，插件化是实现...