步步高家教机加密安装包 BPK 研究 (已弃坑)

标签：enable return String BPK APK 已弃 new 安装包

0x00 设备准备

设备	版本
步步高家教机 S5	Android 9.0 / StudyOS V6.3.0 / V1.5.2_220712

0x00 加密说明

步步高家教机内部软件使用特殊的 BPK 加密格式，只有步步高定制的 StudyOS 内的 PackageManager、ActivityManager 可以打开此加密格式，其他未经修改的 PM 和 AM 均无法读取此加密格式，也无法安装它。

步步高定制系统可以同时读取 APK 以及加密 BPK 文件，BPK 在被安装后依旧是 BPK，并不会被解密为 APK。

0x01 加密规律分析

众所周知，APK 软件包的本质就是一个 ZIP 压缩包，而 BPK 同理

APK (ZIP) 文件头	BPK 文件头	释义
50 4B 01 02	42 50 4B 01	目录开始标记
50 4B 03 04	42 50 4B 03	ZIP 文件头标记
50 4B 05 06	42 50 4B 05	目录结束标记
50 4B 07 08	42 50 4B 07	ZIP 分卷标记

BPK 打包并不会修改任何 classes.dex 中的字节码和任何资源文件，同时不会破坏原有 APK 的签名。换句话说，BPK 打包是完全通过操作 ZIP 文件特性实现的。

通过对比相同版本的 BPK、APK 文件 (Google Play Store 10.2.98 036-146496160)，发现两者的大小是完全一致的，并且通过之前得到的结论，BPK 打包的文件并不会破坏原有的 APK 的签名，所以文件的差异就只能在 ZIP 的头部和尾部，一旦动了中间的数据部分，签名就会失效。已经知道了头部的规律，那么查看尾部的最后一段差异，发现和 APK 有较大的区别

0x03 逆向分析

既然 StudyOS 基于 Android，那么必定逃不出 Android 底层运行的规律。借此突破口，我们可以找到一些方法来进行逆向分析。

0. 开启 USB 调试

要开始分析 Android，通过 Adb 调试是最方便的方式，第一步自然是开启 Adb 调试授权。

快速点击五次 设置 -> 关于设备 中的传播名称，会提示 "检查USB调试授权"，最终当然是返回没有权限的，那么这个授权是如何实现的？正好设置 (Settings.apk) 并未经过加密，反编译设置中的相关类可以发现一些端倪

com.android.settings.AboutSettingsEx

点击传播名称后，系统会向云控后端请求

POST /os-app/app/usbScreenDebug/getUsbScreenDebugStatusByMachineId h2
Host: os-app.eebbk.net
accountid: 1#######9	# 步步高账号
devicemodel: S5		# 机器型号
machineid: 7H7#########K	# 机器序列号
apkversioncode: 4010200		# 设置版本号
apkpackagename: com.android.settings	# 设置包名
deviceosversion: V1.4.3_200818	# 机器固件版本
content-type: application/x-www-form-urlencoded
content-length: 23
accept-encoding: gzip
user-agent: okhttp/3.11.0

machineId=7H7#########K		# 机器序列号

云控则会返回

h2 200
date: ###, ## ### 2022 ##:##:## GMT
content-type: application/json;charset=UTF-8
content-length: 80
strict-transport-security: max-age=15724800; includeSubDomains

{"stateCode":"0","stateInfo":"成功","data":"4c3f15b8e914f5d20bb108bf2ad8da5b"}

此处的 data 被 DES 加密了，通过工具类 com.android.settings.remoteusb.DesUtil 即可解密

import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

public class DesUtil {
    public static String decrypt(String keyStr, String hexStr) {
        return decrypt(keyStr, hexStr, "UTF-8");
    }

    public static String decrypt(String keyStr, String hexStr, String encoding) {
        try {
            byte[] desBytes = decrypt(keyStr.getBytes(encoding), hexStr2ByteArr(hexStr));
            return new String(desBytes, encoding);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    public static byte[] decrypt(byte[] keyBytes, byte[] hexBytes) throws Exception {
        try {
            Key deskey = getKey(keyBytes);
            Cipher decryptCipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec("xgspring".getBytes());
            decryptCipher.init(2, deskey, ips);
            return decryptCipher.doFinal(hexBytes);
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    private static Key getKey(byte[] keyBytes) throws Exception {
        DESedeKeySpec spec = new DESedeKeySpec(keyBytes);
        SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
        Key deskey = keyfactory.generateSecret(spec);
        return deskey;
    }

    public static byte[] hexStr2ByteArr(String strIn) {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;
        byte[] arrOut = new byte[iLen / 2];
        for (int i = 0; i < iLen; i += 2) {
            String strTmp = new String(arrB, i, 2);
            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
        }
        return arrOut;
    }
}

解密的结果类似 {"status":0}，这个 status 还要进行一个三目运算，然后会被返回

if (usbStateBean != null) {
	String str = HttpManager.TAG;
	Log.i(str, "Serial = " + sn + " state = " + usbStateBean.getStatus());
	return usbStateBean.getStatus() == 1 ? 1 : 0;
}

继续追踪 AboutSettingsEx 流程，可以分析出，1 是允许开启 USB 调试，而 0 是不允许

private void handleSuccess() {
    AboutSettingsEx fragment = (AboutSettingsEx) this.fragmentWeakReference.get();
    if (fragment != null && !fragment.getActivity().isFinishing()) {
        fragment.setDevelopmentItemEnable(true);
        Toast.makeText(fragment.getActivity(), "USB调试授权成功", 0).show();
    }
}

private void handleFailed(int failedCode) {
    AboutSettingsEx fragment = (AboutSettingsEx) this.fragmentWeakReference.get();
    if (fragment != null && !fragment.getActivity().isFinishing()) {
        fragment.setDevelopmentItemEnable(false);
        Activity activity = fragment.getActivity();
        Toast.makeText(activity, "USB调试授权失败,code " + failedCode, 0).show();
    }
}

再追踪，发现最终执行 setDevelopmentItemEnable 的语句

public void setDevelopmentItemEnable(boolean enable) {
    if (enable) {
        getPreferenceScreen().addPreference(this.mPreference_development_item);
    } else {
         etPreferenceScreen().removePreference(this.mPreference_development_item);
    }
    this.isRemoteUsbDebugMode = enable;
    DevelopmentSettingsEnabler.setDevelopmentSettingsEnabled(getContext(), enable);
    writeAdbSetting(enable);
    PreferencesDataHelper.setUsbDebugMode(getContext(), enable);
}

那么这就是允许 USB 调试的部分了，只要复现这部分就可以实现 USB 调试的开启，继续跟踪，发现核心代码

// com.android.settings.AboutSettingsEx
public void setDevelopmentItemEnable(boolean enable) {
    if (enable) {
        getPreferenceScreen().addPreference(this.mPreference_development_item);
    } else {
        getPreferenceScreen().removePreference(this.mPreference_development_item);
    }
    this.isRemoteUsbDebugMode = enable;
    DevelopmentSettingsEnabler.setDevelopmentSettingsEnabled(getContext(), enable);
    writeAdbSetting(enable);
    PreferencesDataHelper.setUsbDebugMode(getContext(), enable);
}

protected void writeAdbSetting(boolean enabled) {
    Settings.Global.putInt(getContext().getContentResolver(), "adb_enabled", enabled ? 1 : 0);
}

// com.android.settingslib.development.DevelopmentSettingsEnabler
public class DevelopmentSettingsEnabler {
    public static void setDevelopmentSettingsEnabled(Context context, boolean enable) {
        Settings.Global.putInt(context.getContentResolver(), "development_settings_enabled", enable ? 1 : 0);
        LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("com.android.settingslib.development.DevelopmentSettingsEnabler.SETTINGS_CHANGED"));
    }

    public static boolean isDevelopmentSettingsEnabled(Context context) {
        UserManager um = (UserManager) context.getSystemService("user");
        boolean settingEnabled = Settings.Global.getInt(context.getContentResolver(), "development_settings_enabled", Build.TYPE.equals("eng") ? 1 : 0) != 0;
        boolean hasRestriction = um.hasUserRestriction("no_debugging_features");
        boolean isAdminOrDemo = um.isAdminUser() || um.isDemoUser();
        return isAdminOrDemo && !hasRestriction && settingEnabled;
    }
}

代码关键在于两个 Settings.Global.putInt，在终端中手动执行就行了

settings put global development_settings_enabled 1
settings put global adb_enabled 1

最终成功取得 adb 调试权限

root@azwhikaru:/~# adb devices
List of devices attached
7H7********K   device

root@azwhikaru:/~# adb shell
H7000:/ $ su
H7000:/ #

1. 尝试 Dump classes.dex

虽然目前并不知道步步高的加密解密具体如何实现，但可以肯定的是既然要在 Android 系统中运行，肯定需要有一个解密 / 转换的过程，将 classes.dex 释放到内存或者本地的某个 cache 目录。

而首先需要逆向的是什么？自然是 PackageInsteller.apk (软件包安装程序)，我们安装软件的时候，第一个接触到的就是它；

要从内存中 Dump 出来 classes.dex，这个方法是不是有脱壳内味了？那么就先尝试用脱壳工具吧:

0. 反射大师

反射大师是老牌脱壳软件了，需要依赖 Xposed 框架运行。但遗憾的是年久失修，并不支持 Android 9 中的脱壳，故放弃

1. BlackDex

BlackDex 是一个较新的开源脱壳工具，虽然支持 Android 5.0 ~ 12.X，但并不能脱出 PackageInsteller

2. Frida

Frida 是一款基于 Python 的 HOOK 框架，支持多平台，分为运行在调试机的客户端和运行在被调试端的服务器，通过注入进程的方式来实现劫持应用。这里用一个专门脱壳的开源脚本 frida-dexdump 就行了 (Frida 环境安装教程、Frida 安卓调试教程)

脚本非常简单，在被调试机上启动 server，把要脱壳的程序置于前台，然后在调试机中运行脚本，等几十秒就成功脱壳了

脱完之后可能有好几个 dex，凭直觉都知道应该选最大的。把 dex 拖入 Jadx 中反编译，发现成功脱出了 PackageInstaller 的 classes.dex

2. 分析资源文件

虽然成功 Dump 出来了 classes.dex，但是这样并不能一并 Dump 出 APK 中的资源文件，就无法结合实际 Activity 来分析。这边还需要借助其他工具来分析 Activity 中的组件: 开发者助手

得到了相应 TextView 的 ID 之后，就可以在 Java 代码中寻找 findViewById 之类的方法，来找到 Activity 了。

3. 分析格式识别相关

得到安装界面的 Activity 之后，就可以在 Java 代码中找到相应的类了 com.android.packageinstaller.PackageInstallerActivity

提取关键部分后，得到识别安装包格式的主要代码

// 传入打开的文件路径 packageUri
    public void processPackageUri(Uri packageUri) {
        char c;
        PackageUtil.AppSnippet as;
        this.mPackageURI = packageUri;
        String scheme = packageUri.getScheme(); // 获取文件类型
        int hashCode = scheme.hashCode();
        if (hashCode == -807062458) {
            if (scheme.equals("package")) { // 如果文件类型是 package
                c = 0;
            }
            c = 65535;
        } else if (hashCode != 3143036) {
            if (hashCode == 951530617 && scheme.equals("content")) { // 如果文件类型是 content
                c = 2;
            }
            c = 65535;
        } else {
            if (scheme.equals("file")) { // 如果文件类型是 file
                c = 1;
            }
            c = 65535;
        }
        switch (c) {
            case 0:
                try { // 当文件类型是 package 时
                    this.mPkgInfo = this.mPm.getPackageInfo(packageUri.getSchemeSpecificPart(), 12288); // 当文件类型是 package 时
                } catch (PackageManager.NameNotFoundException e) {
                }
                if (this.mPkgInfo == null) { // 如果 pm 无法获取文件信息 (不是有效安装包)
                    Log.w("BPackageInstaller", "Requested package " + packageUri.getScheme() + " not available. Discontinuing installation"); // 输出 Log
                    showDialogInner(2); // 展示安装失败对话框
                    setPmResult(-2); // 广播安装失败结果
                    return; // 返回
                }
                as = new PackageUtil.AppSnippet(this.mPm.getApplicationLabel(this.mPkgInfo.applicationInfo), this.mPm.getApplicationIcon(this.mPkgInfo.applicationInfo));
                break;
            case 1:
                File sourceFile = new File(packageUri.getPath()); // 当文件类型是 file 时
                PackageParser.Package parsed = PackageUtil.getPackageInfo(this, sourceFile); // 尝试解析为 package
                if (parsed == null) { // 如果解析结果为空 (不是有效安装包)
                    Log.w("BPackageInstaller", "Parse error when parsing manifest. Discontinuing installation"); // 同上
                    showDialogInner(2);
                    setPmResult(-2);
                    return;
                }
                this.mPkgInfo = PackageParser.generatePackageInfo(parsed, (int[]) null, 4096, 0L, 0L, (Set) null, new PackageUserState());
                as = PackageUtil.getAppSnippet(this, this.mPkgInfo.applicationInfo, sourceFile, this.mPkgInfo.versionName);
                break;
            case 2:
                this.mStagingAsynTask = new StagingAsyncTask();
                this.mStagingAsynTask.execute(packageUri);
                return;
            default:
                Log.w("BPackageInstaller", "Unsupported scheme " + scheme); // 如果不是 package、content、file
                setPmResult(-3);
                clearCachedApkIfNeededAndFinish();
                return;
        }
        PackageUtil.initSnippetForNewApp(this, as, 2131361851, this.mCallingLabel); // 获取 package 相关信息 (名称、图标...)
        if (isAllowInstall(packageUri.getPath())) { // 是否允许安装
            this.mInstallPrepareView.setText(getResources().getString(2131755439, as.size));
            this.mAllowButton.setVisibility(0);
        } else {
            this.mInstallPrepareView.setText(getResources().getString(2131755311));
            this.mAllowButton.setVisibility(8);
            Map<String, String> dateMap = notAllowInstallExtraMap(isBBKEncrypted(packageUri.getPath()), this.mPkgInfo);
            Gson gson = new Gson();
            DaInsert.onClickEvent("PackageInstallerActivity", getString(2131755441), getString(2131755442), gson.toJson(dateMap));
        }
        this.mInstallPrepareView.setVisibility(0);
        this.mDenyButton.setVisibility(0);
        this.mOriginatingUid = getOriginatingUid(getIntent());
        initiateInstall();
    }

    private boolean isAllowInstall(String filePath) {
        if (isBBKEncrypted(filePath)) { // 如果是 BBK 加密安装包 (BPK)
            String apkSignatures = getAPKSignatures(this.mPackageURI.getPath()); // 获取安装包签名信息
            String apkSignatures2 = apkSignatures == null ? "" : apkSignatures; // 将 apkSign 赋值给 apkSign2
                                                                               // 返回对比结果，对比是否符合三个签名
            return apkSignatures2.equals("89:3E:2B:8C:1B:B6:9A:DB:DF:36:F4:0F:59:0C:62:82") || apkSignatures2.equals("14:08:7C:E9:ED:28:A7:4F:A1:77:AA:89:14:47:57:4E") || apkSignatures2.equals("40:59:05:EB:57:5C:99:63:4C:87:4A:EE:26:FE:E4:9D");
        }
        return true; // 如果不是 BBK 解密安装包 (APK) 则直接返回 true
    }

    private Map<String, String> notAllowInstallExtraMap(boolean isBBKEncrypted, PackageInfo packageInfo) {
        Map<String, String> dateMap = new HashMap<>();
        dateMap.put("versionName", packageInfo.versionName);
        dateMap.put("packageName", packageInfo.packageName);
        dateMap.put("isAlreadyInstall", this.isAlreadyInstall + "");
        dateMap.put("isEncryptedAPK", isBBKEncrypted + "");
        return dateMap;
    }

    // 获取安装包签名
    private String getAPKSignatures(String apkPath) {
        PackageManager packageManager = getPackageManager();
        PackageInfo packageInfo = packageManager.getPackageArchiveInfo(apkPath, 64);
        String hexString = null;
        try {
            Signature[] signatures = packageInfo.signatures;
            byte[] cert = signatures[0].toByteArray();
            InputStream input = new ByteArrayInputStream(cert);
            CertificateFactory cf = CertificateFactory.getInstance("X509");
            X509Certificate c = (X509Certificate) cf.generateCertificate(input);
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] publicKey = md.digest(c.getEncoded());
            hexString = byte2HexFormatted(publicKey);
            Log.d("BPackageInstaller", "getAPKSignatures: " + hexString);
            return hexString;
        } catch (Exception e) {
            e.printStackTrace();
            return hexString;
        }
    }

此处进行逆向的是 S5 最新固件 V1.6.0_220823 中的 PackageInstaller，这个版本中加入了签名的验证，导致第三方制作的 "直装包" 失效。

4. PM/AM 相关

分析 PackageInstaller 后，发现并没有单独实现软件安装过程，而是直接使用了 PackageManager、PackageInfo。尝试在 Shell 中用 pm 直接安装加密 BPK 也成功了，使用 am 也可以直接调用加密包的 Activity。这意味着整个安装过程中并不涉及解密步骤，解密部分是通过内存操作完成的。

幸好步步高并没有针对 framework 层的东西进行加密，我们可以很轻松地逆向分析 framework 部分。我们提取 /system/framework 中的 service.jar、framework.jar，使用 Jadx 反编译操作。至于 PM 整个安装流程的解析，网上一抓一大把 (Android包管理机制（五）APK是如何被解析的)

在没有开始安装应用前，PackageInstaller 就会通过 PackageManager、PackageInfo 对应用中 AndroidManifest.xml 清单文件精选解析，来获得 APK 的版本号、名称等信息

public void apkInfo(String absPath, Context context) {
    PackageManager pm = context.getPackageManager();
    PackageInfo pkgInfo = pm.getPackageArchiveInfo(absPath,PackageManager.GET_ACTIVITIES);
    if (pkgInfo != null) {
        ApplicationInfo appInfo = pkgInfo.applicationInfo;
        appInfo.sourceDir = absPath;
        appInfo.publicSourceDir = absPath;
        String appName = pm.getApplicationLabel(appInfo).toString();// 得到应用名
        String packageName = appInfo.packageName; // 得到包名
        String version = pkgInfo.versionName; // 得到版本信息
        String pkgInfoStr = String.format("PackageName:%s, Vesion: %s, AppName: %s", packageName, version, appName);
        Log.d("Debug", pkgInfoStr);
    }
}

那么既然正常的 PM 无法解析 BPK，线索肯定就在步步高定制的 PM 中了。我们先针对最容易下手的 getPackageArchiveInfo、getPackageInfo、getApplicationLabel 等方法分析；

通过在源码中搜索，发现了 getPackageArchiveInfo 方法的具体位置，位于 frameworks.jar 的 android.content.pm.PackageManager (frameworks/base/core/java/android/content/pm/PackageManager.java)

反编译 frameworks.jar，定位到相应的类。发现这块代码先在 1 处创建了一个 PackageParser，然后在 2 处调用 parseMonolithicPackage 方法对 APK 进行了解析，最终在 3 处调用 generatePackageInfo 生成并返回一个 PackageInfo

既然对 APK 的解析是通过 PackageParser 来完成的，那么我们继续寻找 PackageParser 的源码。源码位置在 frameworks.jar 的 android.content.pm.PackageParser (frameworks/base/core/java/android/content/pm/PackageParser.java)

这段代码在源码中是有一段注释的: Parse the given APK file, treating it as as a single monolithic package。意思是将给定的 APK 包作为一个整体来解析，除此之外，还有 parseClusterPackage 方法是用来解析 Multiple Apk 的 (Multiple APK support)

分析 parseMonolithicPackage，发现前面有一个判断 coreApp 的部分。coreApp 指的是系统的核心应用，在系统以最小启动 (例如安全模式，或厂商定义的特殊模式) 时就只会启动这些 coreApp，这个属性可以在 AndroidManifest.xml 中定义。为了满足 "最小启动"，这些 Apk 会以 parseMonolithicPackageLite 方法被解析，顾名思义，这是一个比较轻量快速的解析方法，它不需要解析 Apk 的所有部分。

显然日常安装的程序并不属于 coreApp 的范畴，那么我们只需要继续分析 parseBaseApk 部分就行了

2023/01/10 弃坑

标签：enable,return,String,BPK,APK,已弃,new,安装包
From： https://www.cnblogs.com/azwhikaru/p/17122482.html