美文网首页Android开发
Android登录拦截的场景-基于动态代理+Hook的实现

Android登录拦截的场景-基于动态代理+Hook的实现

作者: 小杨哥聊Android | 来源:发表于2022-08-22 17:07 被阅读0次

    如果都写死了所有的Activity跳转都写到一个拦截中,我们又如何实现拦截登录的功能呢?

    我们整理一下思路:

    • 我们需要先使用动态代理+Hook的方式替换全部的Activity启动。
    • 我们在动态代理的回调中我们需要拿到原始的Intent,内部判断是否已经登录
    • 如果已经登录,我们需要放行,直接执行原始的Intent方法。
    • 如果没有登录,我们需要拦截,替换掉原始的Intentn,跳转到我们指定的Intent - LoginActivity的跳转。
    • 那如何实现登录完成继续意图呢?还是和前面的文章一样,还是把之前的inent当参数传递给LoginActivity,然后让LoginActivity帮我们执行之前的Intent。

    接下来我们一步一步来实现这个方案。

    一、动态代理 + Hook 的实现

    在之前的文章我们讲过插件化的实现有点类似,插件化一般是替换系统的 mInstrumentation 为自己的 Instrumentation 。

    而我们这里没有这么麻烦,我们这里需要Hook的是ASM ,是Android启动页面过程中的一个 mInstance 对象,它就是ActivityManagerService。(下面源码为摘抄!)

    startActivity()最终会进入Instrumentation:

    @Override
    public void startActivityForResult(
            String who, Intent intent, int requestCode, @Nullable Bundle options) {
        ...
        Instrumentation.ActivityResult ar =
            mInstrumentation.execStartActivity(
                this, mMainThread.getApplicationThread(), mToken, who,
                intent, requestCode, options);
        ...
    }
    

    Instrumentation的execStartActivity代码:

    public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, String target,
        Intent intent, int requestCode, Bundle options) {
        ...
        try {
            ...
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target, requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }
    

    gDefault是一个Singleton类型的静态常量,它的get()方法返回的是Singleton类中的private T mInstance ,这个mInstance的创建又是在gDefault实例化时通过create()方法实现。gDefault.get()获取到的mInstance实例就是ActivityManagerService(AMS)实例。由于gDefault是一个静态常量,因此可以通过反射获取到它的实例,同时它是Singleton类型的,因此可以获取到其中的mInstance。

    
    static public IActivityManager getDefault() {
        return gDefault.get();
    }
    
    private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
    
            IBinder b = ServiceManager.getService("activity");
            if (false) {
                Log.v("ActivityManager", "default service binder = " + b);
            }
            IActivityManager am = asInterface(b);
            if (false) {
                Log.v("ActivityManager", "default service = " + am);
            }
            return am;
        }
    };
    
    public abstract class Singleton<T> {
        private T mInstance;
    
        protected abstract T create();
    
        public final T get() {
            synchronized (this) {
                if (mInstance == null) {
    
                    mInstance = create();
                }
                return mInstance;
            }
        }
    }
    

    由于8.0系统以下 ,8.0系统 - 9.0系统,10系统 - 12系统 的实现均有差异,需要做一下兼容性处理。我们通过下面的工具类方法实现如何使用反射 + Hook + 动态代理实现效果:

    public class DynamicProxyUtils {
    
        //修改启动模式
        public static void hookAms() {
            try {
    
                Field singletonField;
                Class<?> iActivityManager;
                // 1,获取Instrumentation中调用startActivity(,intent,)方法的对象
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                    // 10.0以上是ActivityTaskManager中的IActivityTaskManagerSingleton
                    Class<?> activityTaskManagerClass = Class.forName("android.app.ActivityTaskManager");
                    singletonField = activityTaskManagerClass.getDeclaredField("IActivityTaskManagerSingleton");
                    iActivityManager = Class.forName("android.app.IActivityTaskManager");
                } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    // 8.0,9.0在ActivityManager类中IActivityManagerSingleton
                    Class activityManagerClass = ActivityManager.class;
                    singletonField = activityManagerClass.getDeclaredField("IActivityManagerSingleton");
                    iActivityManager = Class.forName("android.app.IActivityManager");
                } else {
                    // 8.0以下在ActivityManagerNative类中 gDefault
                    Class<?> activityManagerNative = Class.forName("android.app.ActivityManagerNative");
                    singletonField = activityManagerNative.getDeclaredField("gDefault");
                    iActivityManager = Class.forName("android.app.IActivityManager");
                }
                singletonField.setAccessible(true);
                Object singleton = singletonField.get(null);
    
                // 2,获取Singleton中的mInstance,也就是要代理的对象
                Class<?> singletonClass = Class.forName("android.util.Singleton");
                Field mInstanceField = singletonClass.getDeclaredField("mInstance");
                mInstanceField.setAccessible(true);
    
                Method getMethod = singletonClass.getDeclaredMethod("get");
                Object mInstance = getMethod.invoke(singleton);
                if (mInstance == null) {
                    return;
                }
    
                //开始动态代理
                Object proxy = Proxy.newProxyInstance(
                        Thread.currentThread().getContextClassLoader(),
                        new Class[]{iActivityManager},
                        new AmsHookBinderInvocationHandler(mInstance));
    
                //现在替换掉这个对象
                mInstanceField.set(singleton, proxy);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        //动态代理执行类
        public static class AmsHookBinderInvocationHandler implements InvocationHandler {
    
            private Object obj;
    
            public AmsHookBinderInvocationHandler(Object rawIActivityManager) {
                obj = rawIActivityManager;
            }
    
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                if ("startActivity".equals(method.getName())) {
    
                    Intent raw;
                    int index = 0;
                    for (int i = 0; i < args.length; i++) {
                        if (args[i] instanceof Intent) {
                            index = i;
                            break;
                        }
                    }
    
                    //原始意图
                    raw = (Intent) args[index];
                    YYLogUtils.w("原始意图:" + raw);
    
                    //设置新的Intent-直接制定LoginActivity
                    Intent newIntent = new Intent();
                    String targetPackage = "com.guadou.kt_demo";
                    ComponentName componentName = new ComponentName(targetPackage, LoginDemoActivity.class.getName());
                    newIntent.setComponent(componentName);
    
                    YYLogUtils.w("改变了Activity启动");
    
                    args[index] = newIntent;
    
                    YYLogUtils.w("拦截activity的启动成功" + " --->");
    
                    return method.invoke(obj, args);
    
                }
    
                //如果不是拦截的startActivity方法,就直接放行
                return method.invoke(obj, args);
            }
    
        }
    }
    

    使用的时候我们可以在Application中使用,也可以就在方法中启动:

        mBtnProfile.click {
    
            //启动动态代理
             DynamicProxyUtils.hookAms()
    
            gotoActivity<ProfileDemoActivity>()
        }
    

    这样我们就可以把应用类全部的Activity跳转都替换为我们的LoginActivity了...太坏了。下一步怎么做?

    二、Itent的拦截与处理

    其实和之前Intent的拦截处理有点类似了,我们判断是否登录,如果已经登录了,直接放行,如果没有登录,我们拿到原始的Intent,当做参数传给新的LoginIntent。登录执行完成了让LoginActivity帮我们做后续的意图。

    我们修改动态代理的回调方法:

     //动态代理执行类
        public static class AmsHookBinderInvocationHandler implements InvocationHandler {
    
            private Object obj;
    
            public AmsHookBinderInvocationHandler(Object rawIActivityManager) {
                obj = rawIActivityManager;
            }
    
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                if ("startActivity".equals(method.getName())) {
    
                    //如果已经登录-直接放行
                    if (LoginManager.isLogin()){
                        return method.invoke(obj, args);
                    }
    
                    //如果未登录-获取到原始意图,再替换Intent携带数据到LoginActivity中
                    Intent raw;
                    int index = 0;
                    for (int i = 0; i < args.length; i++) {
                        if (args[i] instanceof Intent) {
                            index = i;
                            break;
                        }
                    }
    
                    //原始意图
                    raw = (Intent) args[index];
                    YYLogUtils.w("原始意图:" + raw);
    
                    //设置新的Intent-直接制定LoginActivity
                    Intent newIntent = new Intent();
                    String targetPackage = "com.guadou.kt_demo";
                    ComponentName componentName = new ComponentName(targetPackage, LoginDemoActivity.class.getName());
                    newIntent.setComponent(componentName);
                    newIntent.putExtra("targetIntent", raw);
    
                    YYLogUtils.w("改变了Activity启动");
    
                    args[index] = newIntent;
    
                    YYLogUtils.w("拦截activity的启动成功" + " --->");
    
                    return method.invoke(obj, args);
    
                }
    
                //如果不是拦截的startActivity方法,就直接放行
                return method.invoke(obj, args);
            }
    
        }
    

    使用的逻辑和Intent那篇文章一样的:

            mBtnProfile.click {
    
                //启动动态代理
                DynamicProxyUtils.hookAms()
    
                gotoProfilePage()
            }
    

    Login页面的处理:

        private var mTargetIntent: Intent? = null
        private var mTargetType = 0
    
         override fun init() {
            mTargetIntent = intent.getParcelableExtra("targetIntent")
            mTargetType = intent.getIntExtra("type", 0)
        }
    
        fun doLogin() {
                showStateLoading()
    
                CommUtils.getHandler().postDelayed({
                    showStateSuccess()
    
                    SP().putString(Constants.KEY_TOKEN, "abc")
    
                    setResult(-1, Intent().apply { putExtra("type", mTargetType) })   //设置Result
    
                    if (mTargetIntent != null) {
                        startActivity(mTargetIntent)
                    }
    
                    finish()
    
                }, 500)
    
            }
    

    实现的效果:(按钮文本没改,其实不是AOP实现的,AOP在另一个分支上)

    总结

    使用动态代理加Hook的方案,我可以理解为Intent方案的升级版。

    继续优化

    其实我们可以加入一个黑名单,白名单的集合来管理,例如我们使用注解标记哪一些页面需要校验登录,然后把这些注解的页面放入一个集合中,在动态代理的回调中,我们判断如果在这些集合中的页面才会判断是否登录,否则直接放行。

    如果需要管理的页面太多,我们可以使用APT代码生成,或者ASM字节码注入等多种方式来实现。网上有一些方案是基于APT代码生成的示例。

    当然如果大家有需求可以自行扩展与实现,比如页面不多的话,可以自己管理一个黑名单集合,如果多的话可以使用APT生成代码。

    主要注意的是,注解的方案只用于跳转页面的场景,如果是弹窗,或者切换Tab的场景就无法实现,还是不够灵活。

    优点与缺点

    相比Intent的方案,使用Hook+动态代理的方法对拦截登录页面进行了封装和处理,集中处理的方式在使用起来更加的便捷,后面的继续执行的逻辑还是和Intent方案一样的逻辑。

    可以说是Intent的进化版,缺点还是和Intent一样,在继续执行这一块还是使用起来麻烦,如果有跳转页面之外的逻辑还是免不了各种type区分和定义。除此之外基于Hook的实现跟系统版本有关系,目前只是兼容到Android12版本,如果后期Androd13 14又有修改,那么可能就无法运行了。

    总的来说,个人不是很推荐这样的方案,当然如果大家使用的是定制设备,系统版本是固定的,那么这样的方案也不是不能用,所以大家需要按需选择。

    关于动态代理+Hook的方案如果大家有更好的方案也可以评论区提出大家一起交流。

    后期我会再出一些拦截登录的其他思路,大家可以和之前的方式做一下对比,看看哪一种更和你的胃口,你们使用的又是哪一种方案?

    相关文章

      网友评论

        本文标题:Android登录拦截的场景-基于动态代理+Hook的实现

        本文链接:https://www.haomeiwen.com/subject/yobigrtx.html