[移动开发] Android Activity防劫持方案

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> Android Activity防劫持方案 -> 正文阅读

[移动开发]Android Activity防劫持方案

最近，安全合规部门又对金融类、银行类app进行了大规模的多方面安全检查，其中有一项安全问题：Activity劫持。其实Android界面防劫持我们app这边也是做了的，但是为啥还会有这些问题呢？自我感觉就是绝不会有此类问题，于是我们向检测部门要了劫持工具，但是事实往往是打脸的。。。。。

那么什么是Activity劫持呢？简单的说就是我们APP正常的Activity界面被恶意攻替换上仿冒的恶意Activity界面进行攻击和非法用途。界面劫持攻击通常难被识别出来，其造成的后果必然会给用户带来严重损失。

举个例子来说，当用户打开安卓手机上的某一应用，进入到登陆页面，这时，恶意软件侦测到用户的这一动作，立即弹出一个与该应用界面相同的Activity，覆盖掉了合法的Activity，用户几乎无法察觉，该用户接下来输入用户名和密码的操作其实是在恶意软件的Activity上进行的，最终会发生什么就可想而知了。

那么应该怎么防护呢？目前是还没有什么专门针对 Activity 劫持的防护方法，因为，这种攻击是用户层面上的，现在还无法从代码层面上根除。但是，我们可以适当地在 APP 中给用户一些警示信息，如toast提示.“某某app正在后台运行”。

前面说到公司app被检测到Activity界面被劫持问题，其实我们项目也有代码逻辑处理劫持问题，但是现在看来还是不够完善的，项目中用的是监听app生命周期方法去做的，在app处于后台时，toast提醒用户，用到了两个库：


    //Gooogle官方获取App生命周期的监听器
    implementation "android.arch.lifecycle:extensions:1.1.1"
    annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

接着需要实现LifecycleObserver

public class AppLifeCycleImpl implements LifecycleObserver {

    private final static String sDES = "MDroidS正在后台运行，请注意了！";
    
    public AppLifeCycleImpl() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void create() {
    }

    //App处于前台可见状态。
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start() {
        UILog.e("AppLifeCycleImpl start");
    }

    //App重新进入前台
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void resume() {
        UILog.e("AppLifeCycleImpl resume");

    }

    //此后App进入不可见状态/后台
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void pause() {
        UILog.e("AppLifeCycleImpl pause");

    }

    //App进入后台或者熄灭屏幕
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop() {
        UILog.e("AppLifeCycleImpl stop");
        UIToast.showShort(sDES);

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        UILog.e("AppLifecycleObserver onDestroy");
    }
}

然后在自己的application中注册监这个Observer


    ProcessLifecycleOwner.get().getLifecycle().addObserver(new AppLifeCycleImpl());

在这里会有个问题，当我们申请权限时或在个别手机上这个玩意也会吐司，我真是吐了，所以在这个基础上又做了一些操作，完善后的AppLifeCycleImpl：

public class AppLifeCycleImpl implements LifecycleObserver {

    private final static String sDES = "MDroidS正在后台运行，请注意了！";
    private boolean isBackground = false;

    public AppLifeCycleImpl() {
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void create() {
    }

    //App处于前台可见状态。
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start() {
        UILog.e("AppLifeCycleImpl start");
    }

    //App重新进入前台
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void resume() {
        UILog.e("AppLifeCycleImpl resume");
        isBackground = false;

    }

    //此后App进入不可见状态/后台
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void pause() {
        // 放在pause中，加快显示防劫持的提示信息
        UILog.e("AppLifeCycleImpl pause");
        // 增加appToBackground判断，兼容部分手机误判
        if (AppUtils.isAppForeground()) {
            return;
        }
        isBackground = true;
        UIToast.showShort(sDES);
    }

    //App进入后台或者熄灭屏幕
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop() {
        UILog.e("AppLifeCycleImpl stop");
        if (!isBackground) {
            isBackground = true;
            UIToast.showShort(sDES);
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        UILog.e("AppLifecycleObserver onDestroy");
    }
}

其实就是加了一层判断和一个isBackground 标识，其中isAppForeground()方法在uitlcodex库里，引入即可：


  implementation'com.blankj:utilcodex:1.30.6'

然后就是这个玩意也被检测出页面劫持问题，其实大多数开发者想到的就是用这个去监听app生命周期，毕竟比较简单，但是现在这个不中用了，于是上网一搜寻找解决办法，网上的办法都是大同小异，多多少少都会有一些问题，最后吸取了一些精华整理出来的方案。

网上一些方案的需求又不符合我们项目逻辑，如：

package com.littlejerk.sample.util;

import android.app.ActivityManager;
import android.app.KeyguardManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author : HHotHeart
 * @date : 2021/8/23 22:07
 * @desc : 描述
 */
public class AntiHijackingUtil {
    public static final String TAG = "AntiHijackingUtil";

    /**
     * 检测当前Activity是否安全
     */
    public static boolean checkActivity(Context context) {
        PackageManager pm = context.getPackageManager();
        // 查询所有已经安装的应用程序
        List<ApplicationInfo> listAppcations =
                pm.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
        Collections.sort(listAppcations, new ApplicationInfo.DisplayNameComparator(pm));// 排序

        List<String> safePackages = new ArrayList<>();
        for (ApplicationInfo app : listAppcations) {// 这个排序必须有.
            if ((app.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
                safePackages.add(app.packageName);
            }
        }
        // 得到所有的系统程序包名放进白名单里面.
        ActivityManager activityManager =
                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        String runningActivityPackageName;
        int sdkVersion;
        try {
            sdkVersion = Integer.valueOf(android.os.Build.VERSION.SDK);
        } catch (NumberFormatException e) {
            sdkVersion = 0;
        }
        if (sdkVersion >= 21) {// 获取系统api版本号,如果是5x系统就用这个方法获取当前运行的包名
            runningActivityPackageName = getCurrentPkgName(context);
        } else {
            runningActivityPackageName =
                    activityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
        }
        // 如果是4x及以下,用这个方法.
        if (runningActivityPackageName != null) {
            // 有些情况下在5x的手机中可能获取不到当前运行的包名，所以要非空判断。
            if (runningActivityPackageName.equals(context.getPackageName())) {
                return true;
            }
            // 白名单比对
            for (String safePack : safePackages) {
                if (safePack.equals(runningActivityPackageName)) {
                    return true;
                }
            }
        }
        return false;
    }

    private static String getCurrentPkgName(Context context) {
        // 5x系统以后利用反射获取当前栈顶activity的包名.
        ActivityManager.RunningAppProcessInfo currentInfo = null;
        Field field = null;
        int START_TASK_TO_FRONT = 2;
        String pkgName = null;
        try {
            // 通过反射获取进程状态字段.
            field = ActivityManager.RunningAppProcessInfo.class.getDeclaredField("processState");
        } catch (Exception e) {
            e.printStackTrace();
        }
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List appList = am.getRunningAppProcesses();
        ActivityManager.RunningAppProcessInfo app;
        for (int i = 0; i < appList.size(); i++) {
            //ActivityManager.RunningAppProcessInfo app : appList
            app = (ActivityManager.RunningAppProcessInfo) appList.get(i);
            //表示前台运行进程.
            if (app.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
                Integer state = null;
                try {
                    state = field.getInt(app);// 反射调用字段值的方法,获取该进程的状态.
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 根据这个判断条件从前台中获取当前切换的进程对象
                if (state != null && state == START_TASK_TO_FRONT) {
                    currentInfo = app;
                    break;
                }
            }
        }
        if (currentInfo != null) {
            pkgName = currentInfo.processName;
        }
        return pkgName;
    }

    /**
     * 判断当前是否在桌面
     *
     * @param context 上下文
     */
    public static boolean isHome(Context context) {
        ActivityManager mActivityManager =
                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> rti = mActivityManager.getRunningTasks(1);
        return getHomes(context).contains(rti.get(0).topActivity.getPackageName());
    }

    /**
     * 获得属于桌面的应用的应用包名称
     *
     * @return 返回包含所有包名的字符串列表
     */
    private static List<String> getHomes(Context context) {
        List<String> names = new ArrayList<String>();
        PackageManager packageManager = context.getPackageManager();
        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.addCategory(Intent.CATEGORY_HOME);
        List<ResolveInfo> resolveInfo = packageManager.queryIntentActivities(intent,
                PackageManager.MATCH_DEFAULT_ONLY);
        for (ResolveInfo ri : resolveInfo) {
            names.add(ri.activityInfo.packageName);
        }
        return names;
    }

    /**
     * 判断当前是否在锁屏再解锁状态
     *
     * @param context 上下文
     */
    public static boolean isReflectScreen(Context context) {
        KeyguardManager mKeyguardManager =
                (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
        return mKeyguardManager.inKeyguardRestrictedInputMode();
    }
}

然后在Actiivty的onStop()方法调用：


  @Override
    protected void onStop() {
        super.onStop();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 白名单
                boolean safe = AntiHijackingUtil.checkActivity(getApplicationContext());
                // 系统桌面
                boolean isHome = AntiHijackingUtil.isHome(getApplicationContext());
                // 锁屏操作
                boolean isReflectScreen = AntiHijackingUtil.isReflectScreen(getApplicationContext());
                // 判断程序是否当前显示
                if (!safe && !isHome && !isReflectScreen) {
                    Looper.prepare();
                    UIToast.showShort(AppLifeCycleImpl.sDES);
                    Looper.loop();
                }
            }
        }).start();
    }

这个方案实现的情况：

用户主动退出 APP ( 返回键、HOME 键)这种情况下我们不需要给用户弹出警告提示
APP 在锁屏再解锁的情况下我们不需要给用户弹出警告提示
其他应用突然覆盖在我们 APP 上时给出合理的警告提示

实际检测中发现这个方案也检测不到发生页面劫持的情况，所以这个方法也是很鸡肋，再加上其实现的需求和我们项目也不一样。

其实相信大多数app对于进入后台的行为都会toast一下，如果有其它应用的页面覆盖到我们的app，这时自己的app能够及时感知到者行为并且及时通知用户，这样才是比较好地防范劫持问题。

接下来我们以Activity的生命周期作文章，我们都知道Activity的跳转必然会涉及到生命周期的回调，如 A跳转到B生命周期方法回调：

A页面回调onPause()；
B页面回调onCreate()、onResume()，然后回调A的onStop()，如果B页面是透明Activity，则不会回调A的onStop()；
A页面如果跳转到其它app，则app内部肯定不会新建activity，即不会回调onCreate()；
app内部activity之间的切换应该是流畅的（耗时会ANR）,产生ANR情况大都是500ms后的了；

基于上述activity的回调和需求分析，我们可以设计这样的方案：在 Activity 生命周期走到 onPause 时，延时发送一个事件，该事件会触发一个 oast 提醒用户已离开本应用。然后在 onCreate、onResume 中移除延时事件。

上面分析得也差不多了，总得来说有两部分，一是发送延时通知和取消通知toast的工具类，二是监听activity生命周期，然后在合适的周期回调方法中去发送和取消通知。

通知发送和取消工具类如下：


package com.littlejerk.sample.util;

import android.app.Activity;
import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;

import com.littlejerk.library.manager.toast.UIToast;

/**
 * @author : HHotHeart
 * @date : 2021/8/24 20:43
 * @desc : 界面防劫持工具类，通过延时通知的发送和取消实现
 */
public class HijackingPrevent {

    public final static String sDES = "MDroidS正在后台运行，请注意了！";

    /**
     * 退出APP的标识
     */
    private boolean isExit = false;
    /**
     * 延时事件
     */
    private Runnable runnable;
    /**
     * 延时事件发送和取消
     */
    private Handler handler;

    /**
     * 创建单例
     */
    private HijackingPrevent() {
        handler = new Handler(Looper.getMainLooper());
        runnable = new Runnable() {
            @Override
            public void run() {
                if (isExit()) {
                    isExit = false;
                    UIToast.showShort(sDES);
                }
            }
        };
    }

    /**
     * 获取单例
     *
     * @return
     */
    public static HijackingPrevent getInstance() {
        return Holder.S_HIJACKING_PROVENT;
    }

    /**
     * Holder初始化单例
     */
    private static class Holder {
        private static final HijackingPrevent S_HIJACKING_PROVENT = new HijackingPrevent();
    }

    /**
     * 退出activity时，延时通知
     */
    public synchronized void delayNotify(Activity activity) {
        // 不需要通知，则返回
        if (!isNeedNotify(activity)) {
            return;
        }
        setExit(true);
        // 先移除已有的
        handler.removeCallbacks(runnable);
        handler.postDelayed(runnable, 500);

    }

    /**
     * 进入当前app activity时，移除通知
     */
    public synchronized void removeNotify() {
        if (isExit()) {
            setExit(false);
            handler.removeCallbacks(runnable);
        }
    }

    /**
     * 判断是否需要通知Toast
     */
    public synchronized boolean isNeedNotify(Activity activity) {
        if (activity == null) {
            return false;
        }
        String actName = activity.getClass().getName();
        if (TextUtils.isEmpty(actName)) {
            return false;
        }
        //除了申请权限的activity，其它都需要延时通知
        return !actName.contains("UtilsTransActivity");
    }

    /**
     * 是否退出app
     *
     * @return
     */
    public boolean isExit() {
        return isExit;
    }

    /**
     * 设置app退出与否标识
     *
     * @param isExit
     */
    public void setExit(boolean isExit) {
        this.isExit = isExit;
    }
}

对于监听activity生命周期方法，我们可以实现Application.ActivityLifecycleCallbacks接口，然后注册这个回调，至于何时发送这个通知，什么时候取消通知，前面也说的比较清楚。


public class ActivityLifeCycleImpl implements Application.ActivityLifecycleCallbacks {
    private static final String TAG = "ActivityLifeCycleImpl";
    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
        UILog.e(TAG,"onActivityCreated" + activity.getClass().getName());
        // 移除通知
        HijackingPrevent.getInstance().removeNotify();

    }

    @Override
    public void onActivityStarted(@NonNull Activity activity) {

    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {
        UILog.e(TAG,"onActivityResumed");
        // 移除通知
        HijackingPrevent.getInstance().removeNotify();
    }

    @Override
    public void onActivityPaused(@NonNull Activity activity) {
        UILog.e(TAG,"onActivityPaused");
        // 延时通知
        HijackingPrevent.getInstance().delayNotify(activity);
    }

    @Override
    public void onActivityStopped(@NonNull Activity activity) {
        UILog.e(TAG,"onActivityStopped");
    }

    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {

    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {

    }
}

在你的application的onCreate()方法中注册：


   registerActivityLifecycleCallbacks(new ActivityLifeCycleImpl());

其实到这里，方案实现的也差不多了，在这里我们可以观察到HijackingPrevent中对UtilsTransActivity做了拦截处理，UtilsTransActivity是PermissionUtils权限申请的页面，然后，在申请权限request()后调用取消通知的方法，如：

        PermissionUtils.permission(Manifest.permission.CAMERA)
                .callback(new PermissionUtils.SingleCallback() {
                    @Override
                    public void callback(boolean isAllGranted,
                                         @NonNull List<String> granted,
                                         @NonNull List<String> deniedForever,
                                         @NonNull List<String> denied) {

                    }
                }).request();

        HijackingPrevent.getInstance().removeNotify();

这样做的目的就是为了在申请权限的时候不用toast提醒用户的需求，具体看业务人员的要求。有时候一筹莫展时，出去冲浪一下，肯定会有意想不到的收获，站在巨人肩膀上才能看得更远。

最后的方案比较好地解决了合规检查界面防劫持问题，自己也尝试用这个劫持工具去测试其它银行app，发现大多数地都没有toast提示用户app进入后台。新时代农民工应学会思考，融会贯通。

移动开发最新文章

Vue3装载axios和element-ui

android adb cmd

【xcode】Xcode常用快捷键与技巧

Android开发中的线程池使用

Java 和 Android 的 Base64

【Android Jetpack】DataStore

加:2021-08-26 12:13:18 更:2021-08-26 12:13:36

360图书馆购物三丰科技阅读网日历万年历 2025年3日历

-2025/3/4 15:45:48-

图片自动播放器
↓图片自动播放器↓

TxT小说阅读器
↓语音阅读,小说下载,古典文学↓

一键清除垃圾
↓轻轻一点,清除系统垃圾↓

图片批量下载器
↓批量下载图片,美女图库↓

网站联系: qq:121756557 email:121756557@qq.com IT数码