如果启动一个未注册的Activity

简述

要启动未注册的Activity主要是要逃避AMS的检测，思路是，检测前要启动的Activity换成注册的，检测通过了，再在启动前换回来。这里主要是两个点。检测前，hookAMS。检测后hookHandler。hook点有很多尽量找静态变量、单例和public

hookAMS

1、android 11举例，启动acitivty是在ATMS中（11之前是AMS，这个自己可以去适配）

2、拿到ATMS的代理。

3、然后ATMS整个动态代理在startActivity之前将Intent 偷梁换柱

4、换成已经注册的Activity之后记得原目标Acitivty存起来，在骗完AMS之后换回来

 
public static void hookAMS() {
    // 10之前
    try {
        Class<?> clazz = Class.forName("android.app.ActivityTaskManager");
        Field singletonField = clazz.getDeclaredField("IActivityTaskManagerSingleton");

        singletonField.setAccessible(true);
        Object singleton = singletonField.get(null);




        Class<?> singletonClass = Class.forName("android.util.Singleton");
        Field mInstanceField = singletonClass.getDeclaredField("mInstance");
        mInstanceField.setAccessible(true);
        Method getMethod = singletonClass.getMethod("get");
        Object mInstance = getMethod.invoke(singleton);

        Class IActivityTaskManagerClass = Class.forName("android.app.IActivityTaskManager");

        Object mInstanceProxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{IActivityTaskManagerClass}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if ("startActivity".equals(method.getName())) {
                            int index = -1;

                            // 获取 Intent 参数在 args 数组中的index值
                            for (int i = 0; i < args.length; i++) {
                                if (args[i] instanceof Intent) {
                                    index = i;
                                    break;
                                }
                            }
                            // 生成代理proxyIntent -- 孙悟空（代理）的Intent
                            Intent proxyIntent = new Intent();
                            // 这个包名是宿主的
                            proxyIntent.setClassName("com.leo.amsplugin",
                                    ProxyActivity.class.getName());

                            // 原始Intent能丢掉吗？保存原始的Intent对象
                            Intent intent = (Intent) args[index];
                            proxyIntent.putExtra(TARGET_INTENT, intent);

                            // 使用proxyIntent替换数组中的Intent
                            args[index] = proxyIntent;
                        }

                        // 原来流程
                        return method.invoke(mInstance, args);
                    }
                });

        // 用代理的对象替换系统的对象
        mInstanceField.set(singleton, mInstanceProxy);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

hookHandler

hookAMS完成，欺骗了AMS，接下来要把Intent中的原目标扶起回正位，
启动Activity要用handler，我们从这里hook吧

1、Activtiy thread 中的handler用来启动activity class H extends Handler

2、handlerMessage中的EXECUTE_TRANSACTION(159)来启动activity

3、
final ClientTransaction transaction = (ClientTransaction) msg.obj;--包含Intent

mTransactionExecutor.execute(transaction);--执行启动

launchActivityItem中有Intent，而ta继承于ClientTransactionItem，而ClientTransaction中包含List<ClientTransactionItem>

4、所以我只要拿到msg就可以拿到Intent。
msg.obj --> ClientTransaction --> List mActivityCallbacks(LaunchActivityItem)
--> private Intent mIntent 替换

5、handlerMessage(MSG)之前有个callback也可以拿到msg。则会callback是一个接口，如果重写这个接口可就可重新handlerMessage这个方法，然后操作msg。

6、ActivityThread当中，Handler的构建没有传参数。

...//去ActivityThread.java里看
@UnsupportedAppUsage
final H mH = new H();
    ...
class H extends Handler //也没写构造方法
    
...//去Handler.java里看
 
@Deprecated
public Handler() {
    this(null, false);
}   

7、实际上callback是看，那么我自己替换系统的call就可以啦

8、那我通过反射拿Handler中的mCallback，

 public void hoodHandler() {
    try {
        Class<?> clazz = Class.forName("android.app.ActivityThread");
        Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
        activityThreadField.setAccessible(true);
        Object activityThread = activityThreadField.get(null);

        Field mHField = clazz.getDeclaredField("mH");
        mHField.setAccessible(true);
        final Handler mH = (Handler) mHField.get(activityThread);

        Field mCallbackField = Handler.class.getDeclaredField("mCallback");
        mCallbackField.setAccessible(true);

        mCallbackField.set(mH, new Handler.Callback() {

            @Override
            public boolean handleMessage(Message msg) {
                switch (msg.what) {
                    case 159:
                        // msg.obj = ClientTransaction
                        try {
                            // 获取 List<ClientTransactionItem> mActivityCallbacks 对象
                            Field mActivityCallbacksField = msg.obj.getClass()
                                    .getDeclaredField("mActivityCallbacks");
                            mActivityCallbacksField.setAccessible(true);
                            List mActivityCallbacks = (List) mActivityCallbacksField.get(msg.obj);

                            for (int i = 0; i < mActivityCallbacks.size(); i++) {
                                // 打印 mActivityCallbacks 的所有item:
                                //android.app.servertransaction.WindowVisibilityItem
                                //android.app.servertransaction.LaunchActivityItem

                                // 如果是 LaunchActivityItem，则获取该类中的 mIntent 值，即 proxyIntent
                                if (mActivityCallbacks.get(i).getClass().getName()
                                        .equals("android.app.servertransaction.LaunchActivityItem")) {
                                    Object launchActivityItem = mActivityCallbacks.get(i);
                                    Field mIntentField = launchActivityItem.getClass()
                                            .getDeclaredField("mIntent");
                                    mIntentField.setAccessible(true);
                                    Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);

                                    // 获取启动插件的 Intent，并替换回来
                                    Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
                                    if (intent != null) {
                                        mIntentField.set(launchActivityItem, intent);
                                    }
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        break;
                }
                return false;
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
    }

}

总结

一个分为两步

1、hookAMS主要就是逃避ams检测,让ams检测的是一个已经注册了的activity。

2、hookHandler在生成activity之前再把activity换回来。

所以一定要熟悉动态代理，反射和Activity的启动流程。

主要通过hook，核心在于hook点

插桩
1、尽量找 静态变量 单利
2、public

动态代理

AMS检测之前我改下