Risk 设计初衷
随着我们项目的用户群体不断壮大，渐渐的我们会从 Bugly 日志等地方发现一些灰产使用 Hook 、自动化脚本等对我们应用进行数据的抓取、对正常用户进行骚扰与欺诈，我们希望能够有一款框架能够对这些“非法用户”进行识别，这就是我们 Risk 框架设计的初衷。
Risk 原理
Hook 检测
典型框架：Xpatch、Xposed、太极
对于 Hook 来说自然不得不提大名鼎鼎的 Xposed 由于他是免费、开源的，Xposed 已经有了种种可以绕过常规检测的方法，由于市面上的检测代码并不准确，我们通过分析 Xposed 源码，找出了以下这几个方案进行检测。
方案1：Class.forName()
我们通过 bugly 上报上来的异常 Class 路径，人工筛选过后通过“配置中心”下发到 Risk 框架中通过 Class.forName() 来进行检测，这个方法较为准确，但是非常依靠人力来做异常 Class 路径的识别与下发，并且没法第一时间发现，只能作为后手方案。方案2：com.android.internal.os.ZygoteInit
我们如果去阅读 Xposed 源码，可以发现他是抢在我们 App 的 ZygoteInit 初始化之前初始化的，那这样我们就可以通过检测 exception 堆栈来进行识别，但是需要注意，Hook 可以隐藏自身的信息，详情参见：利用Xposed躲过Xposed检测 所以我们这边利用了一个双重检测，经过线上的测试发现双重检测(指的是最底层的俩层堆是否都为 ZygoteInit ，一般的 Hook 框架只隐藏最后一层堆)还是较为有效的，大部份 Hook 框架使用者并未发现这个检测方案，代码如下：
// 应用都是从 zygoteInit 初始化出来的，所以我们判断最底层是否是 zygote 就可以判断是否被hook了
if (!sZygoteInit.equals(exception.getStackTrace()[(exception.getStackTrace().length - 1)].getClassName())) {
if(sZygoteInit.equals(exception.getStackTrace()[(exception.getStackTrace().length - 2)].getClassName())){
checkCredit(isTrusted);
isTrusted = false;
next();
return;
}
}
- 方案3：Application.class.getSuperclass()
由于 Hook 存在二次打包后入侵 Application 进行应用内 Hook 的情况，这种框架十分难检测，它的原理大致是这样：二次打包目标应用，替换目标应用的 Application 并在替换后的 Application 的 static 方法块写上初始化 Hook 的相关代码，这样就能在第一次时间初始化 Hook 框架，所以我们需要校验 Application 的完整性，这里已线上项目为例，被二次打包前的代码：
public class XjbApplication extends BaseApplication {
private static final String TAG = "XjbApplication";
private static XjbApplication instance;
private XjbApplicationHelper xjbAppHelper = XjbApplicationHelper.getInstance();
private Context mApplicationContext;
public XjbApplication() {
super();
instance = this;
Loger.init(BuildConfig.DEBUG);
Log.i(TAG, "APP instanced");
}
.........
二次打包后的代码：
public class XjbApplication extends HookApplication {
private static final String TAG = "XjbApplication";
private static XjbApplication instance;
private XjbApplicationHelper xjbAppHelper = XjbApplicationHelper.getInstance();
private Context mApplicationContext;
public XjbApplication() {
super();
instance = this;
Loger.init(BuildConfig.DEBUG);
Log.i(TAG, "APP instanced");
}
.........
public class HookApplication extends Application {
static {
Hook.init();
}
.........
所以，根据以上的情况我们先校验代码的完整性：
XjbApplication.class.getSuperclass();
BaseApplication.class.getSuperclass();
需要特别注意，有些入侵式 Hook 框架会更改 AndroidManifest.xml 中声明的 Application ，暂时还没找到什么比较好的检测方案。
多开检测
典型框架：virtualApp
关于多开检测网上的一些方案都十分有效，难点是由于多开框架众多，我们需要集成进大量的检测代码，下面分享俩个较为有效的方案
方案1：Context.getCacheDir()
VirtualApp、dkplugin 等框架在生成文件目录的时候，往往生成的目录很奇怪，例如
nativeLibraryDirectories=[/data/user/0/dkplugin.aix.ttr/virtual/data/user/0/com.xingjiabi.shengsheng/lib]
特别注意，检测 nativeLibraryDirectories 目录十分有效方案2：/proc/self/maps
/proc/self/maps 中出现包含 /vbox/data/ 、 /shadow/data/ 、 /virtual/data/ 的动态库，则运行在多开环境下。由于许多多开软件都是开源的，不排除某些大手子自己改名重新编译。
模拟器检测
模拟器检测并无太多技巧，主要检测 CPU 架构、ROM 名称、手机是否一直在充电中、电池电量等。
但是模拟器的系统应用都有一个特点，就是它们的 nativeLibraryDir 最终目录都是 x86，MuMu模拟器、逍遥模拟器、蓝叠模拟器、夜神模拟器、雷电模拟器 都经过验证，无一例外针对这个漏洞进行检测，准确率会比较高。
/**
* @author：杨浩
* 创建日期：2019-12-19
* 功能简介：用于检测虚拟机的工具类
* aosp:Android Open-Source Project 一般虚拟机都是基于这个开发的
* 目前能检测到的模拟器有：MuMu模拟器、逍遥模拟器、蓝叠模拟器、夜神模拟器、雷电模拟器、480 * 800 分辨率的脚本
*/
public class AntiAospUtils {
private static final String SCAN_DEVICE_TIME = "s_aosp_device_time";
/**
* 开始扫描设备信息
*
* @param accountId 账号，用于保存上一次扫描的时间，每隔 3 天才会扫描一次，如果扫描到模拟器就上报
* @param contex
*/
public static void startScanDeviceInfo(final String accountId, final Context contex) {
startScanDeviceInfo(accountId, contex, null);
}
/**
* 开始扫描设备信息
*
* @param accountId 账号，用于保存上一次扫描的时间，每隔 3 天才会扫描一次，如果扫描到模拟器就上报
* @param context
* @param scanDeviceListener 扫描完成回调
*/
public static void startScanDeviceInfo(final String accountId, final Context context, final ScanDeviceListener scanDeviceListener) {
ScanDevicePlanWrapper scanScreenInfo = new ScanDevicePlanWrapper(new ScanScreenInfo());
ScanDevicePlanWrapper scanAppInfo = new ScanDevicePlanWrapper(new ScanAppInfo());
ScanDevicePlanWrapper scanCpuInfo = new ScanDevicePlanWrapper(new ScanCpuInfo());
scanCpuInfo.setNextScanDevicePlanWrapper(scanAppInfo);
scanAppInfo.setNextScanDevicePlanWrapper(scanScreenInfo);
DeviceScanInfo deviceScanInfo = scanCpuInfo.scanDevice(context);
// 判断是否可疑设备 或者是否模拟器设备，都需要上报
if (deviceScanInfo.isFaker() || deviceScanInfo.isBadDevice()) {
LogUploadUtil.postAospDeviceLog(deviceScanInfo);
}
if (scanDeviceListener != null) {
scanDeviceListener.onComplete(deviceScanInfo);
}
}
private static class ScanDevicePlanWrapper implements ScanDevicePlanAble {
/**
* 下一个扫描器
*/
@Nullable
public ScanDevicePlanWrapper mNextScanDevicePlanWrapper;
@NotNull
public ScanDevicePlanAble mScanDevicePlan;
public ScanDevicePlanWrapper(ScanDevicePlanAble scanDevicePlan) {
mScanDevicePlan = scanDevicePlan;
}
public void setNextScanDevicePlanWrapper(ScanDevicePlanWrapper nextScanDevicePlanWrapper) {
mNextScanDevicePlanWrapper = nextScanDevicePlanWrapper;
}
@Override
public DeviceScanInfo scanDevice(Context context) throws Exception {
@Nullable
DeviceScanInfo nextDeviceScanInfo = null;
if (mNextScanDevicePlanWrapper != null) {
nextDeviceScanInfo = mNextScanDevicePlanWrapper.scanDevice(context);
// 判断是否需要扫描
if (!isAllScanInfo() && nextDeviceScanInfo.isBadDevice()) {
return nextDeviceScanInfo;
}
}
DeviceScanInfo currentDeviceScanInfo = mScanDevicePlan.scanDevice(context);
if (nextDeviceScanInfo != null) {
// 如果其他扫描器扫描出来有用的信息就保存下来
String scanInfoTemp = nextDeviceScanInfo.getScanInfo();
currentDeviceScanInfo.setScanInfo(scanInfoTemp + " || " + currentDeviceScanInfo.getScanInfo());
if (nextDeviceScanInfo.isBadDevice()) {
// 发现模拟器
currentDeviceScanInfo.setBadDevice(true);
} else if (nextDeviceScanInfo.isFaker()) {
// 发现疑似模拟器
currentDeviceScanInfo.setFaker(true);
}
}
return currentDeviceScanInfo;
}
@Override
public boolean isAllScanInfo() {
return mScanDevicePlan.isAllScanInfo();
}
}
private interface ScanDevicePlanAble {
/**
* 扫描设备
*
* @param context
* @return
* @throws Exception
*/
@NotNull
public DeviceScanInfo scanDevice(Context context) throws Exception;
/**
* 是否需要完整的扫描信息，因为这边的扫描器是链式的
* return true 的情况下，会将所有的链式扫描器跑一遍，为的是完整的模拟器信息
* return false 的情况下，只要有其中一个扫描器扫描到信息，本扫描器将不扫描信息
*
* @return
*/
public boolean isAllScanInfo();
}
/**
* 扫描 cpu 的架构信息
*/
private static class ScanCpuInfo implements ScanDevicePlanAble {
@Override
public DeviceScanInfo scanDevice(Context context) throws Exception {
if (checkDeviceForumX86()) {
return new DeviceScanInfo("scanCpuInfo：x86 == true", true);
} else {
return new DeviceScanInfo("scanCpuInfo：x86 == false", false);
}
}
/**
* cpu 架构信息不重要，如果之前其他扫描器已经扫描到了，这里就不需要工作
*
* @return
*/
@Override
public boolean isAllScanInfo() {
return false;
}
}
/**
* 针对 app 做扫描
* 模拟器的系统应用都有一个特点，就是它们的 nativeLibraryDir 最终目录都是 x86
* MuMu模拟器、逍遥模拟器、蓝叠模拟器、夜神模拟器、雷电模拟器 都经过验证，无一例外
* 针对这个漏洞进行检测，准确率会比较高
*/
private static class ScanAppInfo implements ScanDevicePlanAble {
/**
* 模拟器身上的标记
*/
private static final String BAD_TAG = "x86";
// --------------------- 需要扫描的包名 ---------------------
/**
* 拨打电话
*/
private final String CALL = "com.android.server.telecom";
/**
* 通讯录
*/
private final String CONTACTS = "com.android.contacts";
/**
* 网页渲染器
*/
private final String WEB_VIEW = "com.android.webview";
/**
* 系统设置
*/
private final String SYSTEM_SETTING = "com.android.settings";
/**
* Android 默认的浏览器
*/
private final String SYSTEM_BROWSER = "com.android.browser";
/**
* 需要扫描的应用包名
*/
private final String[] ALL_SCAN_PACKAGE_INFO = new String[]{CALL, CONTACTS, WEB_VIEW, SYSTEM_SETTING, SYSTEM_BROWSER};
@Override
public DeviceScanInfo scanDevice(Context context) throws Exception {
// 判断是否扫描成功过
// 正常的手机不太可能一个应用都没有找到
// 如果出现这种情况的话，一般只有俩种可能，1、系统没给权限（默认都是给的）2、被 Hook 了
// 这种情况下需要考虑一下这个设备是否是有问题的了
boolean isScanDeviceComplete = false;
PackageManager packageManager = context.getPackageManager();
if (packageManager == null) {
return new DeviceScanInfo("scanPackageInfo：packageManager == null", false, isScanDeviceComplete);
}
for (String scanPackageInfo : ALL_SCAN_PACKAGE_INFO) {
try {
PackageInfo packageInfo = packageManager.getPackageInfo(scanPackageInfo, PackageManager.GET_ACTIVITIES);
if (packageInfo != null) {
String nativeLibraryDir = packageInfo.applicationInfo.nativeLibraryDir;
// 如果 nativeLibraryDir 没有获取到的话，非常可疑
if (nativeLibraryDir != null) {
isScanDeviceComplete = true;
if (nativeLibraryDir.contains(BAD_TAG)) {
return new DeviceScanInfo("scanPackageInfo：" + scanPackageInfo + "." + BAD_TAG, true);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
return new DeviceScanInfo("scanPackageInfo：scanPackageInfo == null", false, !isScanDeviceComplete);
}
@Override
public boolean isAllScanInfo() {
return true;
}
}
/**
* 扫描屏幕的宽高与物理尺寸来区分模拟器
* 目前发现针对的脚本，都需要限定屏幕的尺寸，就算他进行了 hook 也不太可能针对获取屏幕分辨率进行处理
* 所以这里检测屏幕分辨率
*/
private static class ScanScreenInfo implements ScanDevicePlanAble {
// --------------------- 可疑的屏幕分辨率 ---------------------
/**
* 貌似脚本会固定这个宽高，先检测看看
*/
private static final Integer SCREEN_WIDTH[] = new Integer[]{480, 540};
private static final Integer SCREEN_HEIGHT[] = new Integer[]{800, 960};
@Override
public DeviceScanInfo scanDevice(Context context) throws Exception {
DisplayMetrics dm = context.getResources().getDisplayMetrics();
int screenWidth = dm.widthPixels;
int screenHeight = dm.heightPixels;
// 判断是否是可疑宽高
if (Arrays.asList(SCREEN_HEIGHT).contains(screenHeight) && Arrays.asList(SCREEN_WIDTH).contains(screenWidth)) {
// 计算屏幕物理尺寸
double diagonalPixels = Math.sqrt(Math.pow(screenWidth, 2) + Math.pow(screenHeight, 2));
double size = new BigDecimal(diagonalPixels / (160 * dm.density)).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
return new DeviceScanInfo("ScanScreenInfo：badPixel width-" + screenWidth + "、height-" + screenHeight + "-size：" + size, true);
}
return new DeviceScanInfo("ScanScreenInfo：normal《 " + "width-" + screenWidth + "、height-" + screenHeight + " 》", false);
}
@Override
public boolean isAllScanInfo() {
return true;
}
}
/**
* 扫描设备回调
*/
public interface ScanDeviceListener {
public void onComplete(DeviceScanInfo info);
}
/**
* 扫描的结果信息
*/
public static class DeviceScanInfo {
/**
* 扫描的结果
*/
private String mScanInfo = "";
/**
* 是否模拟器
*/
private boolean isBadDevice = false;
/**
* 是否是可疑的设备
*/
private boolean isFaker = false;
public DeviceScanInfo(String scanInfo, boolean isBadDevice, boolean isFaker) {
mScanInfo = scanInfo;
this.isBadDevice = isBadDevice;
this.isFaker = isFaker;
}
public DeviceScanInfo(String scanInfo, boolean isBadDevice) {
mScanInfo = scanInfo;
this.isBadDevice = isBadDevice;
}
public String getScanInfo() {
return mScanInfo;
}
public void setScanInfo(String scanInfo) {
mScanInfo = scanInfo;
}
public boolean isBadDevice() {
return isBadDevice;
}
public void setBadDevice(boolean badDevice) {
isBadDevice = badDevice;
}
public boolean isFaker() {
return isFaker;
}
public void setFaker(boolean faker) {
isFaker = faker;
}
@NonNull
@Override
public String toString() {
if (isBadDevice) {
return "BadDevice: " + isBadDevice + "。" + mScanInfo;
}
return "Faker: " + isFaker + "，" + mScanInfo;
}
}
}
/**
* @author：杨浩 项目：haibaobase
* 创建日期：2019-09-03
* 功能简介：
*/
class DeviceUtils {
public static final String ABI_X86 = "x86";
public static final String ABI_MIPS = "mips";
public static enum ARCH {
Unknown, ARM, X86, MIPS, ARM64,
}
private static ARCH sArch = ARCH.Unknown;
// see include/uapi/linux/elf-em.h
private static final int EM_ARM = 40;
private static final int EM_386 = 3;
private static final int EM_MIPS = 8;
private static final int EM_AARCH64 = 183;
// /system/lib/libc.so
// XXX: need a runtime check
public static synchronized ARCH getMyCpuArch() {
byte[] data = new byte[20];
File libc = new File(Environment.getRootDirectory(), "lib/libc.so");
if (libc.canRead()) {
RandomAccessFile fp = null;
try {
fp = new RandomAccessFile(libc, "r");
fp.readFully(data);
int machine = (data[19] << 8) | data[18];
switch (machine) {
case EM_ARM:
sArch = ARCH.ARM;
break;
case EM_386:
sArch = ARCH.X86;
break;
case EM_MIPS:
sArch = ARCH.MIPS;
break;
case EM_AARCH64:
sArch = ARCH.ARM64;
break;
default:
Log.e("NativeBitmapFactory", "libc.so is unknown arch: " + Integer.toHexString(machine));
break;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fp != null) {
try {
fp.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
return sArch;
}
public static String get_CPU_ABI() {
return Build.CPU_ABI;
}
public static String get_CPU_ABI2() {
try {
Field field = Build.class.getDeclaredField("CPU_ABI2");
if (field == null)
return null;
Object fieldValue = field.get(null);
if (!(fieldValue instanceof String)) {
return null;
}
return (String) fieldValue;
} catch (Exception e) {
}
return null;
}
public static boolean supportABI(String requestAbi) {
String abi = get_CPU_ABI();
if (!TextUtils.isEmpty(abi) && abi.equalsIgnoreCase(requestAbi))
return true;
String abi2 = get_CPU_ABI2();
return !TextUtils.isEmpty(abi2) && abi.equalsIgnoreCase(requestAbi);
}
public static boolean supportX86() {
return supportABI(ABI_X86);
}
public static boolean supportMips() {
return supportABI(ABI_MIPS);
}
public static boolean isARMSimulatedByX86() {
ARCH arch = getMyCpuArch();
return !supportX86() && ARCH.X86.equals(arch);
}
public static boolean isMiBox2Device() {
String manufacturer = Build.MANUFACTURER;
String productName = Build.PRODUCT;
return manufacturer.equalsIgnoreCase("Xiaomi")
&& productName.equalsIgnoreCase("dredd");
}
public static boolean isMagicBoxDevice() {
String manufacturer = Build.MANUFACTURER;
String productName = Build.PRODUCT;
return manufacturer.equalsIgnoreCase("MagicBox")
&& productName.equalsIgnoreCase("MagicBox");
}
public static boolean isProblemBoxDevice() {
return isMiBox2Device() || isMagicBoxDevice();
}
public static boolean isRealARMArch() {
ARCH arch = getMyCpuArch();
return (supportABI("armeabi-v7a") || supportABI("armeabi")) && ARCH.ARM.equals(arch);
}
public static boolean isRealX86Arch() {
ARCH arch = getMyCpuArch();
return supportABI(ABI_X86) || ARCH.X86.equals(arch);
}
/**
* 检测设备是否是 x86
*
* @return
*/
public static boolean checkDeviceForumX86() {
return isRealX86Arch() || isARMSimulatedByX86() || supportX86();
}
}
二次打包检测
由于所有二次打包的检测都会被 Hook 绕过，所以请先检测 Hook ，特别是二次打包后入侵 Application 进行应用内 Hook 的情况，所以不可信任任何 Java 层的代码，下列方案都是在 JNI 层执行。
- 方案1：通过读取 Apk 的 Zip包信息进行校验
如何开发 Risk 框架
因为 Risk 设计之初就是以代码被反编译的情况下，也能保证逻辑不被发现并且正确工作，所以需要有很多额外的设计，请后期维护 Risk 框架的同事请按照以下设计思路：
设计代码蜜罐
用最简单的名称例如 RiskManager 或者明显的字符串，让破解者在第一时能找到，这块代码不可信任，出现问题或者被移除都不影响真正的流程，一定要避免被混淆。保证逻辑分散
在保证逻辑连贯性的前提下，将代码分散开，用 extends 来将代码分布在各个子类、父类中。尽量混淆
用 JNI 代替原生代码
不要使用能够被阅读的包名
设计指南
对于 api 相关的设计推荐大量加入盐方法并且分散，以防止被发现核心逻辑。
· Hook 检测
// 初始化 hook 监听，必须在主线程中执行
new HookManager()
// 假方法，迷惑反编译者
.fakerMethods()
// 假方法，迷惑反编译者
.fakerInitHook()
// 真初始化方法
.initHookManager()
// 真方法 获取需要观测的对象，这里的数据推荐使用配置中心下载
.saveInfo("Xposed==com.bly.chaos0-0de.robv.android.xposed.XposedBridge0-0de.robv.android.xposed.installer0-0xposed0-0de.robv.android.xposed.XposedHelper")
// 假方法，迷惑反编译者
.fakerMethods2()
// 假方法，迷惑反编译者
.startHookObserver()
.fakerJniScanHook()
// 真正 jni 检测的方法
.jniScanHook()
// 假方法，迷惑反编译者
.fakerJniScanHook2();