Android13 系统/用户证书安装相关分析总结(一) 证书分类以及安装流程分析 ...

一、前言

说这个问题之前，先说一下配景。是为了写一个SDK的接口，需求大抵是增加证书安装卸载的接口（系统、用户）。于是了解了一下证书相关的处置处罚逻辑。
二、根本概念

1、系统中的证书安装、查察功能

入口：
安装证书：系统设置（Settings）–>安全–> 加密与凭据 --> 安装证书
查察证书：系统设置（Settings）–>安全–> 加密与凭据 -->信任的凭据
两个入口图如下

看到图又有两个概念，用户证书和系统证书。这两者的区别，笔者临时只发现数据库中存放的type不同，证书存放的路径不同，其他的差异临时也不是很清楚。而在wifi模块中的证书验证看到路径写死的是系统证书的路径。
2、证书的种类和存放路径

种类：
1.按照权限区分:可以分为系统证书和用户证书
2.按照用途区分:CA证书、VPN和应用用户证书、WiFi证书 (Android 8.1的系统在这个上面settings层面没有做区分，底层处置处罚上不确定有没有作区分)
3、证书存放的路径和格式

系统证书: /system/etc/security/cacerts
用户证书:/data/misc/user/0/cacerts-added
证书格式：系统证书一般以 .0 后缀，用户证书settings中支持安装crt
三、证书安装流程整理

下面重点分析一下Ca证书安装的流程
安装入口：InstallCertificateFromStorage
安装流程写在前面，解开释在背面
Settings —> InstallCertificateFromStorage.java --> InstallCaCertificateWarning.java---->
/vendor/mediatek/proprietary/packages/apps/MtkSettings/src/com/android/settings/security/InstallCaCertificateWarning.java
CertInstaller —> CertInstallerMain.java .onCreate() --> installingCaCertificate() —>confirmDeviceCredential()—>startOpenDocumentActivity()----> 选择证书文件后 ----> startInstallActivity() ---->CertInstaller.class onCreate() —>extractPkcs12OrInstall() —>installOthers() —>installCertificateOrShowNameDialog()—>InstallVpnAndAppsTrustAnchorsTask().execute()—>CredentialHelper.installVpnAndAppsTrustAnchors() —>IKeyChainService.installCaCertificate() ---->
packages/apps/KeyChain/src/com/android/keychain/KeyChainService.java
KeyChainService.installCaCertificate() ---->
external/conscrypt/platform/src/main/java/org/conscrypt/TrustedCertificateStore.java
TrustedCertificateStore.installCertificate() ---->writeCertificate()

1. /**
2. * Creates a warning dialog explaining the consequences of installing a CA certificate
3. * This is displayed before a CA certificate can be installed from Settings.
4. */
5. public class InstallCaCertificateWarning extends Activity {
7.     @Override
8.     public void onCreate(@Nullable Bundle savedInstanceState) {
9.         super.onCreate(savedInstanceState);
10.       ...
11.               mixin.setSecondaryButton(
12.                 new FooterButton.Builder(this)
13.                         .setText(R.string.certificate_warning_install_anyway)
14.                         .setListener(installCaCertificate())
15.                         .setButtonType(FooterButton.ButtonType.OTHER)
16.                         .setTheme(R.style.SudGlifButton_Secondary)
17.                         .build()
18.         );
19.         mixin.getSecondaryButtonView().setFilterTouchesWhenObscured(true);
20.         ...
21.     }
23.     private View.OnClickListener installCaCertificate() {
24.         return v -> {
25.             final Intent intent = new Intent();
26.             intent.setAction(Credentials.INSTALL_ACTION);
27.             intent.putExtra(Credentials.EXTRA_CERTIFICATE_USAGE, Credentials.CERTIFICATE_USAGE_CA);
28.             startActivity(intent);
29.             finish();
30.         };
31.     }
33. //frameworks/base/keystore/java/android/security/Credentials.java
34. public static final String INSTALL_ACTION = "android.credentials.INSTALL";
36. //packages/apps/CertInstaller/AndroidManifest.xml
37.          <activity android:name=".CertInstallerMain"
38.               android:theme="@style/Transparent"
39.               android:configChanges="orientation|keyboardHidden|screenSize"
40.               android:exported="true">
41.              <intent-filter>
42.                  <action android:name="android.credentials.INSTALL"/>
43.                  <category android:name="android.intent.category.DEFAULT"/>
44.              </intent-filter>
45.              <intent-filter>
46.                  <action android:name="android.intent.action.VIEW"/>
47.                  <category android:name="android.intent.category.DEFAULT"/>
48.                  <data android:mimeType="application/x-x509-ca-cert"/>
49.                  <data android:mimeType="application/x-x509-user-cert"/>
50.                  <data android:mimeType="application/x-x509-server-cert"/>
51.                  <data android:mimeType="application/x-pkcs12"/>
52.                  <data android:mimeType="application/x-pem-file"/>
53.                  <data android:mimeType="application/pkix-cert"/>
54.                  <data android:mimeType="application/x-wifi-config"/>
55.              </intent-filter>
56.          </activity>

复制代码

从上面的来看settings 调用了CertInstaller 的CertInstallerMain 界面准备安装证书。
这里注意笔者发现了一个细节，那就是安装证书界面在选择文件的时候被限制了文件类型，比如系统证书中的.0后缀的都是灰显的，这是因为在上面的AndroidManifest.xml 中声明了mimeType，如果想安装.0的有两种方式:1、转换格式2、本身写demo调用证书安装的接口。笔者发现接口调用底层实现最终是把证书的数据变成byte数组，以是不受限制。
接着看调用链
CertInstallerMain 中最终调用startInstallActivity方法，跳转到CertInstaller，最终调用CredentialHelper.java 的installVpnAndAppsTrustAnchors方法，之后再次跨历程调用另一个服务KeyChainService的方法，流程代码如下：

1.     // packages/apps/CertInstaller/src/com/android/certinstaller/CertInstallerMain.java
2.     private void startInstallActivity(String mimeType, Uri uri) {
3.         if (mimeType == null) {
4.             mimeType = getContentResolver().getType(uri);
5.         }
6.         String target = MIME_MAPPINGS.get(mimeType);
7.         if (target == null) {
8.             Log.e(TAG, "Unknown MIME type: " + mimeType + ". "
9.                     + Log.getStackTraceString(new Throwable()));
10.             Toast.makeText(this, R.string.invalid_certificate_title, Toast.LENGTH_LONG).show();
11.             return;
12.         }
13.         if (WIFI_CONFIG.equals(target)) {
14.             startWifiInstallActivity(mimeType, uri);
15.         }
16.         else {
17.             InputStream in = null;
18.             try {
19.                 in = getContentResolver().openInputStream(uri);
20.                 final byte[] raw = readWithLimit(in);
21.                 Intent intent = getIntent();
22.                 intent.putExtra(target, raw);
23.                 startInstallActivity(intent);
24.             } catch (IOException e) {
25.                 Log.e(TAG, "Failed to read certificate: " + e);
26.                 Toast.makeText(this, R.string.cert_read_error, Toast.LENGTH_LONG).show();
27.             } finally {
28.                 IoUtils.closeQuietly(in);
29.             }
30.         }
31.     }
33. //packages/apps/CertInstaller/src/com/android/certinstaller/CredentialHelper.java
34.     boolean installVpnAndAppsTrustAnchors(Context context, IKeyChainService keyChainService) {
35.         final TrustedCertificateStore trustedCertificateStore = new TrustedCertificateStore();
36.         for (X509Certificate caCert : mCaCerts) {
37.             byte[] bytes = null;
38.             try {
39.                 bytes = caCert.getEncoded();
40.             } catch (CertificateEncodingException e) {
41.                 throw new AssertionError(e);
42.             }
43.             if (bytes != null) {
44.                 try {
45.                     keyChainService.installCaCertificate(bytes);
46.                 } catch (RemoteException e) {
47.                     Log.w(TAG, "installCaCertsToKeyChain(): " + e);
48.                     return false;
49.                 }
51.                 String alias = trustedCertificateStore.getCertificateAlias(caCert);
52.                 if (alias == null) {
53.                     Log.e(TAG, "alias is null");
54.                     return false;
55.                 }
57.                 maybeApproveCaCert(context, alias);
58.             }
59.         }
60.         return true;
61.     }

复制代码

到了KeyChainService这个方法，瞬间以为好像马上找到了最终的答案。这里会调用 TrustedCertificateStore.installCertificate()方法，于是看一下TrustedCertificateStore的方法。看到最后发现，就是一个简单的像指定路径写文件。而写路径的user对应的路径就是我们前面提到的用户证书的路径/data/misc/user/0/cacerts-added。
这里简单注意一下，因为最重调用到了java的一些类，以是必要格外注意Android 的权限机制。为什么这么说，是因为Android调用者会被系统标记，不同的历程所拥有的权限是有差异的，比如我们平时读写存储必要权限，另有SElinux权限等等。至于为什么，笔者先卖个关子，背面再说
至此安装流程就竣事了，代码如下所示：

1. //xqt552_sys/packages/apps/KeyChain/src/com/android/keychain/KeyChainService.java
2.         @Override public String installCaCertificate(byte[] caCertificate) {
3.             final CallerIdentity caller = getCaller();
4.             Preconditions.checkCallAuthorization(isSystemUid(caller) || isCertInstaller(caller),
5.                     MSG_NOT_SYSTEM_OR_CERT_INSTALLER);
6.             final String alias;
7.             String subject = null;
8.             final boolean isSecurityLoggingEnabled = mInjector.isSecurityLoggingEnabled();
9.             final X509Certificate cert;
10.             try {
11.                 cert = parseCertificate(caCertificate);
13.                 final boolean isDebugLoggable = Log.isLoggable(TAG, Log.DEBUG);
14.                 subject = cert.getSubjectX500Principal().getName(X500Principal.CANONICAL);
15.                 if (isDebugLoggable) {
16.                     Log.d(TAG, String.format("Installing CA certificate: %s", subject));
17.                 }
19.                 synchronized (mTrustedCertificateStore) {
20.                     mTrustedCertificateStore.installCertificate(cert);
21.                     alias = mTrustedCertificateStore.getCertificateAlias(cert);
22.                 }
23.             } catch (IOException | CertificateException e) {
24.                 Log.w(TAG, "Failed installing CA certificate", e);
25.                 if (isSecurityLoggingEnabled && subject != null) {
26.                     mInjector.writeSecurityEvent(
27.                             TAG_CERT_AUTHORITY_INSTALLED, 0 /*result*/, subject,
28.                             UserHandle.myUserId());
29.                 }
30.                 throw new IllegalStateException(e);
31.             }
32.             if (isSecurityLoggingEnabled && subject != null) {
33.                 mInjector.writeSecurityEvent(
34.                         TAG_CERT_AUTHORITY_INSTALLED, 1 /*result*/, subject,
35.                         UserHandle.myUserId());
36.             }
38.             // If the caller is the cert installer, install the CA certificate into KeyStore.
39.             // This is a temporary solution to enable CA certificates to be used as VPN trust
40.             // anchors. Ultimately, the user should explicitly choose to install the VPN trust
41.             // anchor separately and independently of CA certificates, at which point this code
42.             // should be removed.
43.             if (CERT_INSTALLER_PACKAGE.equals(caller.mPackageName)|| "android.uid.system:1000".equals(caller.mPackageName)) {
44.                 try {
45.                     mKeyStore.setCertificateEntry(String.format("%s %s", subject, alias), cert);
46.                 } catch(KeyStoreException e) {
47.                     Log.e(TAG, String.format(
48.                             "Attempted installing %s (subject: %s) to KeyStore. Failed", alias,
49.                             subject), e);
50.                 }
51.             }
53.             broadcastLegacyStorageChange();
54.             broadcastTrustStoreChange();
55.             return alias;
56.         }
58. // external/conscrypt/repackaged/platform/src/main/java/com/android/org/conscrypt/TrustedCertificateStore.java
59.     /**
60.      * This non-{@code KeyStoreSpi} public interface is used by the
61.      * {@code KeyChainService} to install new CA certificates. It
62.      * silently ignores the certificate if it already exists in the
63.      * store.
64.      */
65.     @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE)
66.     public void installCertificate(X509Certificate cert) throws IOException, CertificateException {
67.         if (cert == null) {
68.             throw new NullPointerException("cert == null");
69.         }
70.         File system = getCertificateFile(systemDir, cert);
71.         if (system.exists()) {
72.             File deleted = getCertificateFile(deletedDir, cert);
73.             if (deleted.exists()) {
74.                 // we have a system cert that was marked deleted.
75.                 // remove the deleted marker to expose the original
76.                 if (!deleted.delete()) {
77.                     throw new IOException("Could not remove " + deleted);
78.                 }
79.                 return;
80.             }
81.             // otherwise we just have a dup of an existing system cert.
82.             // return taking no further action.
83.             return;
84.         }
85.         File user = getCertificateFile(addedDir, cert);
86.         if (user.exists()) {
87.             // we have an already installed user cert, bail.
88.             return;
89.         }
90.         // install the user cert
91.         writeCertificate(user, cert);
92.     }
93.     private void writeCertificate(File file, X509Certificate cert)
94.             throws IOException, CertificateException {
95.         File dir = file.getParentFile();
96.         dir.mkdirs();
97.         dir.setReadable(true, false);
98.         dir.setExecutable(true, false);
99.         OutputStream os = null;
100.         try {
101.             os = new FileOutputStream(file);
102.             os.write(cert.getEncoded());
103.         } finally {
104.             IoUtils.closeQuietly(os);
105.         }
106.         file.setReadable(true, false);
107.     }

复制代码

那么问题来了，大抵搞懂了根本流程，安装用户证书的流程可以想办法调用背面的KeyChainService类的方法来实现，那如果安装成系统证书又该怎么办呢？遗憾的是，笔者找了半天发现没有办法，只能本身加接口了。
在思考了一下之后，笔者想到了两种方法，一种是把证书复制到系统证书的存放路径，另一种是创建一个新的目录，把这个目录在用到证书的时候多读一个路径。笔者选了后一种方法。缘故起因是系统路径下变成可写的会有可能把系统内置的正式删除从而导致系统异常。那么如何解决这个问题，另有证书如何验证这些问题放在后续文章解决。
————————————————

1.                         版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

复制代码

原文链接：https://blog.csdn.net/fighting_2017/article/details/134581186

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。