diff --git a/interfaces/kits/napi/src/cm_napi_get_system_cert_info.cpp b/interfaces/kits/napi/src/cm_napi_get_system_cert_info.cpp index f067e67e9bc1cf09155b8d7662892f4104752c58..d0a04f1d19f8e30f6b1621799a316de6d933347e 100644 --- a/interfaces/kits/napi/src/cm_napi_get_system_cert_info.cpp +++ b/interfaces/kits/napi/src/cm_napi_get_system_cert_info.cpp @@ -169,15 +169,23 @@ static void GetCertInfoExecute(napi_env env, void *data) GetCertInfoAsyncContext context = static_cast(data); context->certificate = (struct CertInfo *)CmMalloc(sizeof(struct CertInfo)); - if (context->certificate != nullptr) { - (void)memset_s(context->certificate, sizeof(struct CertInfo), 0, sizeof(struct CertInfo)); + if (context->certificate == nullptr) { + CM_LOG_E("malloc certificate fail"); + context->result = CMR_ERROR_MALLOC_FAIL; + return; } + (void)memset_s(context->certificate, sizeof(struct CertInfo), 0, sizeof(struct CertInfo)); if (context->store == CM_SYSTEM_TRUSTED_STORE) { context->result = CmGetCertInfo(context->cmContext, context->certUri, context->store, context->certificate); } else { context->certificate->certInfo.data = (uint8_t *)CmMalloc(MAX_LEN_CERTIFICATE); + if (context->certificate->certInfo.data == nullptr) { + CM_LOG_E("malloc certificate certInfo data fail"); + context->result = CMR_ERROR_MALLOC_FAIL; + return; + } context->certificate->certInfo.size = MAX_LEN_CERTIFICATE; context->result = CmGetUserCertInfo(context->certUri, context->store, context->certificate); } diff --git a/interfaces/kits/napi/src/cm_napi_get_system_cert_list.cpp b/interfaces/kits/napi/src/cm_napi_get_system_cert_list.cpp index 6411e1a3a048b4a99f2116064581268c22e9291b..695ba08b2acaafa93bd0788af47f76718a77e0f0 100644 --- a/interfaces/kits/napi/src/cm_napi_get_system_cert_list.cpp +++ b/interfaces/kits/napi/src/cm_napi_get_system_cert_list.cpp @@ -150,19 +150,26 @@ static void GetCertListExecute(napi_env env, void *data) GetCertListAsyncContext context = static_cast(data); context->certificateList = (struct CertList *)CmMalloc(sizeof(struct CertList)); - if (context->certificateList != nullptr) { - context->certificateList->certAbstract = nullptr; - context->certificateList->certsCount = 0; + if (context->certificateList == nullptr) { + CM_LOG_E("malloc certificateList fail"); + context->result = CMR_ERROR_MALLOC_FAIL; + return; } + context->certificateList->certAbstract = nullptr; + context->certificateList->certsCount = 0; if (context->store == CM_SYSTEM_TRUSTED_STORE) { context->result = CmGetCertList(context->cmContext, context->store, context->certificateList); } else { uint32_t buffSize = MAX_COUNT_CERTIFICATE * sizeof(struct CertAbstract); context->certificateList->certAbstract = (struct CertAbstract *)CmMalloc(buffSize); - if (context->certificateList->certAbstract != nullptr) { - (void)memset_s(context->certificateList->certAbstract, buffSize, 0, buffSize); - context->certificateList->certsCount = MAX_COUNT_CERTIFICATE; + if (context->certificateList->certAbstract == nullptr) { + CM_LOG_E("malloc certificateList certAbstract fail"); + context->result = CMR_ERROR_MALLOC_FAIL; + return; } + (void)memset_s(context->certificateList->certAbstract, buffSize, 0, buffSize); + context->certificateList->certsCount = MAX_COUNT_CERTIFICATE; + context->result = CmGetUserCertList(context->store, context->certificateList); } } diff --git a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager.c b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager.c index 4aaedb7a58870acf39e4cf3aa53b2de97197d651..63c9013b452aac364f7affd043ec017decd17b14 100644 --- a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager.c +++ b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager.c @@ -34,6 +34,7 @@ #include "cert_manager_auth_mgr.h" #include "cert_manager_uri.h" #include "cert_manager_storage.h" +#include #define MAX_FILES_IN_DIR 1000 #define CERT_MANAGER_MD5_SIZE 32 @@ -1191,6 +1192,32 @@ int32_t CmServiceGetAppCertList(const struct CmContext *context, uint32_t store, return CM_SUCCESS; } +static int32_t CherkCertCountBeyondMax(const char *path, const char *fileName) +{ + int32_t ret = CM_FAILURE; + + do { + uint32_t tempCount = GetCertCount(path); + if (tempCount < MAX_COUNT_CERTIFICATE) { + ret = CM_SUCCESS; + break; + } + + char fullFileName[CM_MAX_FILE_NAME_LEN] = {0}; + if (snprintf_s(fullFileName, CM_MAX_FILE_NAME_LEN, CM_MAX_FILE_NAME_LEN - 1, "%s/%s", path, fileName) < 0) { + CM_LOG_E("mkdir full name failed"); + ret = CM_FAILURE; + break; + } + + if (access(fullFileName, F_OK) == 0) { + ret = CM_SUCCESS; + break; + } + } while (0); + return ret; +} + int32_t CmWriteUserCert(const struct CmContext *context, struct CmMutableBlob *pathBlob, const struct CmBlob *userCert, const struct CmBlob *certAlias, struct CmBlob *certUri) { @@ -1204,6 +1231,13 @@ int32_t CmWriteUserCert(const struct CmContext *context, struct CmMutableBlob *p break; } + ret = CherkCertCountBeyondMax((char*)pathBlob->data, userUri); + if(ret != CM_SUCCESS) { + CM_LOG_E("cert count beyond maxcount, can't install"); + ret = CMR_ERROR_INVALID_ARGUMENT; + break; + } + if (CmFileWrite((char*)pathBlob->data, userUri, 0, userCert->data, userCert->size) != CMR_OK) { CM_LOG_E("Failed to write certificate: %s in to %s", certAlias->data, pathBlob->data); ret = CMR_ERROR_WRITE_FILE_FAIL; diff --git a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_query.c b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_query.c index 79732e854bbf13ba650d9c01c0a22f9a785c595a..e4382fcf3a421e6f0068fd1b60a7b624249c33db 100755 --- a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_query.c +++ b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_query.c @@ -214,6 +214,10 @@ static int32_t CreateCertFile(struct CertFilePath *certFilePath, const char *pat int32_t ret = CM_SUCCESS; uint32_t i = *certCount; uint32_t fileNums = GetCertCount(path); + if (fileNums == 0) { + CM_LOG_I("no cert file in path"); + return CM_SUCCESS; + } void *d = CmOpenDir(path); if (d == NULL) { @@ -258,6 +262,11 @@ static int32_t CreateCertFile(struct CertFilePath *certFilePath, const char *pat int32_t CreateCertFileList(const struct CmMutableBlob *certPathList, struct CmMutableBlob *certFileList) { + if (certPathList->size == 0) { + CM_LOG_I("dir is empty"); + return CM_SUCCESS; + } + struct CertFilePath *certFilePath = (struct CertFilePath *)CMMalloc(sizeof(struct CertFilePath) * MAX_COUNT_CERTIFICATE); if (certFilePath == NULL) { @@ -423,6 +432,11 @@ void CmFreeCertBlob(struct CertBlob *certBlob) int32_t CmGetMatchedCertIndex(const struct CmMutableBlob *certFileList, const struct CmBlob *certUri) { + if (certFileList->size == 0) { + CM_LOG_I("no cert file exist"); + return MAX_COUNT_CERTIFICATE; + } + struct CertFilePath *certFilePath = (struct CertFilePath *)certFileList->data; uint32_t matchIndex = certFileList->size; diff --git a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_service.c b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_service.c index a3b0a3d0d46499156b15770abcfbef05c3f7bfd2..7393fa4e927378c33b5a5411bd365c9bd6f05707 100755 --- a/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_service.c +++ b/services/cert_manager_standard/cert_manager_engine/main/core/src/cert_manager_service.c @@ -237,20 +237,10 @@ int32_t CmServiceGetCertList(const struct CmContext *context, uint32_t store, st return ret; } -int32_t CmServiceGetCertListPack(const struct CmContext *context, uint32_t store, - const struct CmMutableBlob *certFileList, struct CmBlob *certificateList) +static int32_t CmGetCertListPack(const struct CertBlob *certBlob, uint32_t *status, uint32_t certCount, + struct CmBlob *certificateList) { uint32_t offset = 0; - uint32_t status[MAX_COUNT_CERTIFICATE] = {0}; - struct CertBlob certBlob; /* uri[certCount] + subjectName[certCount] + certAlias[certCount] */ - (void)memset_s(&certBlob, sizeof(struct CertBlob), 0, sizeof(struct CertBlob)); - - int32_t ret = CmGetCertListInfo(context, store, certFileList, &certBlob, status); - if (ret != CM_SUCCESS) { - CM_LOG_E("CmGetCertListInfo fail"); - return ret; - } - uint32_t buffSize = sizeof(uint32_t) + (sizeof(uint32_t) + MAX_LEN_SUBJECT_NAME + sizeof(uint32_t) + sizeof(uint32_t) + MAX_LEN_URI + sizeof(uint32_t) + MAX_LEN_CERT_ALIAS) * MAX_COUNT_CERTIFICATE; if (certificateList->size < buffSize) { @@ -258,14 +248,15 @@ int32_t CmServiceGetCertListPack(const struct CmContext *context, uint32_t store return CMR_ERROR_BUFFER_TOO_SMALL; } certificateList->size = buffSize; - ret = CopyUint32ToBuffer(certFileList->size, certificateList, &offset); + + int32_t ret = CopyUint32ToBuffer(certCount, certificateList, &offset); if (ret != CM_SUCCESS) { CM_LOG_E("Copy cert count failed"); return ret; } - for (uint32_t i = 0; i < certFileList->size; i++) { - ret = CopyBlobToBuffer(&(certBlob.subjectName[i]), certificateList, &offset); + for (uint32_t i = 0; i < certCount; i++) { + ret = CopyBlobToBuffer(&(certBlob->subjectName[i]), certificateList, &offset); if (ret != CM_SUCCESS) { CM_LOG_E("Copy certificate subject failed"); return ret; @@ -275,17 +266,45 @@ int32_t CmServiceGetCertListPack(const struct CmContext *context, uint32_t store CM_LOG_E("Copy certificate status failed"); return ret; } - ret = CopyBlobToBuffer(&(certBlob.uri[i]), certificateList, &offset); + ret = CopyBlobToBuffer(&(certBlob->uri[i]), certificateList, &offset); if (ret != CM_SUCCESS) { CM_LOG_E("Copy certificate uri failed"); return ret; } - ret = CopyBlobToBuffer(&(certBlob.certAlias[i]), certificateList, &offset); + ret = CopyBlobToBuffer(&(certBlob->certAlias[i]), certificateList, &offset); if (ret != CM_SUCCESS) { CM_LOG_E("Copy certificate certAlias failed"); return ret; } } + return ret; +} + +int32_t CmServiceGetCertListPack(const struct CmContext *context, uint32_t store, + const struct CmMutableBlob *certFileList, struct CmBlob *certificateList) +{ + if (certFileList->size == 0) { + CM_LOG_I("no cert file exist"); + return CM_SUCCESS; + } + + uint32_t status[MAX_COUNT_CERTIFICATE] = {0}; + struct CertBlob certBlob; + (void)memset_s(&certBlob, sizeof(struct CertBlob), 0, sizeof(struct CertBlob)); + int32_t ret = CmGetCertListInfo(context, store, certFileList, &certBlob, status); + if (ret != CM_SUCCESS) { + CM_LOG_E("CmGetCertListInfo fail"); + CmFreeCertBlob(&certBlob); + return ret; + } + + ret = CmGetCertListPack(&certBlob, status, certFileList->size, certificateList); + if (ret != CM_SUCCESS) { + CM_LOG_E("CmGetCertListPack fail"); + CmFreeCertBlob(&certBlob); + return ret; + } + CmFreeCertBlob(&certBlob); return ret; } @@ -300,7 +319,6 @@ int32_t CmGetServiceCertInfo(const struct CmContext *context, const struct CmBlo int32_t ret = CM_SUCCESS; struct CmMutableBlob certFileList = { 0, NULL }; - uint32_t matchIndex = 0; do { ret = CmServiceGetCertList(context, store, &certFileList); if (ret != CM_SUCCESS) { @@ -308,10 +326,10 @@ int32_t CmGetServiceCertInfo(const struct CmContext *context, const struct CmBlo break; } - matchIndex = CmGetMatchedCertIndex(&certFileList, certUri); - if (matchIndex == certFileList.size) { - CM_LOG_E("certFile of certUri don't matched"); - ret = CM_FAILURE; + uint32_t matchIndex = CmGetMatchedCertIndex(&certFileList, certUri); + if ((matchIndex == MAX_COUNT_CERTIFICATE) || (matchIndex == certFileList.size)) { + CM_LOG_I("certFile of certUri don't matched"); + ret = CM_SUCCESS; break; } @@ -340,6 +358,11 @@ int32_t CmGetServiceCertInfo(const struct CmContext *context, const struct CmBlo int32_t CmServiceGetCertInfoPack(const struct CmBlob *certificateData, uint32_t status, struct CmBlob *certificateInfo) { + if (certificateInfo->size == 0) { + CM_LOG_I("cert file is not exist"); + return CM_SUCCESS; + } + int32_t ret = CM_SUCCESS; uint32_t offset = 0; uint32_t buffSize = sizeof(uint32_t) + MAX_LEN_CERTIFICATE + sizeof(uint32_t); diff --git a/services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc/cm_ipc_service.c b/services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc/cm_ipc_service.c index 48e5538f537e26b7f75dd87ae2da1d2606aece71..a8a1bf69786104d973854206598042aa3ff64f5b 100644 --- a/services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc/cm_ipc_service.c +++ b/services/cert_manager_standard/cert_manager_service/main/os_dependency/idl/cm_ipc/cm_ipc_service.c @@ -1473,13 +1473,6 @@ void CmIpcServiceAbort(const struct CmBlob *paramSetBlob, struct CmBlob *outData CmFreeParamSet(¶mSet); } -static int32_t CmCheckCallerPermission(const struct CmContext *ipcInfo) -{ - (void)ipcInfo; - - return CM_SUCCESS; -} - void CmIpcServiceGetUserCertList(const struct CmBlob *paramSetBlob, struct CmBlob *outData, const struct CmContext *context) { @@ -1494,15 +1487,15 @@ void CmIpcServiceGetUserCertList(const struct CmBlob *paramSetBlob, struct CmBlo }; do { - ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); - if (ret != CM_SUCCESS) { - CM_LOG_E("GetUserCertList get input params failed, ret = %d", ret); + if (!CmHasCommonPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("GetUserCertList get input params failed, ret = %d", ret); break; } @@ -1523,9 +1516,7 @@ void CmIpcServiceGetUserCertList(const struct CmBlob *paramSetBlob, struct CmBlo if (ret != CM_SUCCESS) { CmSendResponse(context, ret, NULL); } - if (certFileList.data != NULL) { - CmFreeCertFiles(&certFileList); - } + CmFreeCertFiles(&certFileList); CmFreeParamSet(¶mSet); } @@ -1545,15 +1536,15 @@ void CmIpcServiceGetUserCertInfo(const struct CmBlob *paramSetBlob, struct CmBlo }; do { - ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); - if (ret != CM_SUCCESS) { - CM_LOG_E("GetUserCertInfo get input params failed, ret = %d", ret); + if (!CmHasCommonPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("GetUserCertInfo get input params failed, ret = %d", ret); break; } @@ -1593,15 +1584,15 @@ void CmIpcServiceSetUserCertStatus(const struct CmBlob *paramSetBlob, struct CmB }; do { - ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); - if (ret != CM_SUCCESS) { - CM_LOG_E("SetUserCertStatus get input params failed, ret = %d", ret); + if (!CmHasCommonPermission() || !CmHasPrivilegedPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("SetUserCertStatus get input params failed, ret = %d", ret); break; } @@ -1629,15 +1620,15 @@ void CmIpcServiceInstallUserCert(const struct CmBlob *paramSetBlob, struct CmBlo }; do { - ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); - if (ret != CM_SUCCESS) { - CM_LOG_E("InstallUserCert get input params failed, ret = %d", ret); + if (!CmHasCommonPermission() || !CmHasPrivilegedPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("InstallUserCert get input params failed, ret = %d", ret); break; } @@ -1667,15 +1658,15 @@ void CmIpcServiceUninstallUserCert(const struct CmBlob *paramSetBlob, struct CmB }; do { - ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); - if (ret != CM_SUCCESS) { - CM_LOG_E("UninstallUserCert get input params failed, ret = %d", ret); + if (!CmHasCommonPermission() || !CmHasPrivilegedPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = GetInputParams(paramSetBlob, ¶mSet, &cmContext, params, CM_ARRAY_SIZE(params)); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("UninstallUserCert get input params failed, ret = %d", ret); break; } @@ -1697,15 +1688,15 @@ void CmIpcServiceUninstallAllUserCert(const struct CmBlob *paramSetBlob, struct struct CmContext cmContext = {0}; do { - ret = CmGetProcessInfoForIPC(&cmContext); - if (ret != CM_SUCCESS) { - CM_LOG_E("CmGetProcessInfoForIPC fail, ret = %d", ret); + if (!CmHasCommonPermission() || !CmHasPrivilegedPermission()) { + CM_LOG_E("caller no permission"); + ret = CMR_ERROR_PERMISSION_DENIED; break; } - ret = CmCheckCallerPermission(&cmContext); + ret = CmGetProcessInfoForIPC(&cmContext); if (ret != CM_SUCCESS) { - CM_LOG_E("caller no permission"); + CM_LOG_E("CmGetProcessInfoForIPC fail, ret = %d", ret); break; } diff --git a/test/unittest/src/cm_user_cert_test.cpp b/test/unittest/src/cm_user_cert_test.cpp index 0193e21d897e48babe5af7e0df36a1c149b6a6b4..2adfae1ba2ff2c28795ba0de2818f326b9108780 100755 --- a/test/unittest/src/cm_user_cert_test.cpp +++ b/test/unittest/src/cm_user_cert_test.cpp @@ -20,6 +20,30 @@ #include "cm_log.h" #include "cm_mem.h" +#include "accesstoken_kit.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" + +void SetUserPermission(void) +{ + const char **perms = new const char *[2]; // 2 permissions + perms[0] = "ohos.permission.ACCESS_CERT_MANAGER_INTERNAL"; // system_basic + perms[1] = "ohos.permission.ACCESS_CERT_MANAGER"; // normal + NativeTokenInfoParams infoInstanceTmp = { + .dcapsNum = 0, + .permsNum = 2, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "TestCertManager", + .aplStr = "system_basic", + }; + + auto tokenId = GetAccessTokenId(&infoInstanceTmp); + SetSelfTokenID(tokenId); + OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); +} + using namespace testing::ext; using namespace CertmanagerTest; namespace { @@ -433,6 +457,7 @@ public: void CmUserCertTest::SetUpTestCase(void) { + SetUserPermission(); } void CmUserCertTest::TearDownTestCase(void) @@ -1093,8 +1118,53 @@ HWTEST_F(CmUserCertTest, UserCertTest025, TestSize.Level0) EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret; } +/** + * @tc.name: UserCertTest026 + * @tc.desc: Test CertManager install max count user cert interface base function + * @tc.type: FUNC + * @tc.require: AR000H0MJ8 /SR000H09N7 + */ +HWTEST_F(CmUserCertTest, UserCertTest026, TestSize.Level0) +{ + int32_t ret; + struct CmBlob userCertTest = { sizeof(g_certData01), (uint8_t *)g_certData01 }; + + for (uint32_t i = 0; i < MAX_COUNT_CERTIFICATE; i++) { + char alias[] = "alias"; + char certAliasBuf[10]; + snprintf_s(certAliasBuf, 10, 9, "%s%u", alias, i); + struct CmBlob certAliasTest = { sizeof(certAliasBuf), (uint8_t *)certAliasBuf }; + uint8_t certUriBuf[MAX_URI_LEN] = {0}; + struct CmBlob certUriTest = { sizeof(certUriBuf), certUriBuf }; + + ret = CmInstallUserTrustedCert(&userCertTest, &certAliasTest, &certUriTest); + EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret; + } + + uint8_t certAliasBuf257[] = "40dc992e"; /* install */ + uint8_t certUriBuf257[MAX_URI_LEN] = {0}; + struct CmBlob certAlias257 = { sizeof(certAliasBuf257), certAliasBuf257 }; + struct CmBlob certUri257 = { sizeof(certUriBuf257), certUriBuf257 }; + + ret = CmInstallUserTrustedCert(&userCertTest, &certAlias257, &certUri257); + EXPECT_EQ(ret, CM_FAILURE) << "Normal user cert Install test failed, recode:" << ret; + + + uint8_t certAliasBuf000[] = "alias0"; /* update */ + uint8_t certUriBuf000[MAX_URI_LEN] = {0}; + struct CmBlob certAlias000 = { sizeof(certAliasBuf000), certAliasBuf000 }; + struct CmBlob certUri000 = { sizeof(certUriBuf000), certUriBuf000 }; + + ret = CmInstallUserTrustedCert(&userCertTest, &certAlias000, &certUri000); + EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret; + + ret = CmUninstallAllUserTrustedCert(); + EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret; } +} + +