diff --git a/bundle.json b/bundle.json index dd2be1b8dad6fb5ddb3d4c0337a7ddb2e3352cb4..2ed8c9d055a7b55caf7f45bc70a67ea7902b225c 100644 --- a/bundle.json +++ b/bundle.json @@ -71,7 +71,8 @@ "service_group": [ "//foundation/distributedhardware/device_manager:device_manager", "//foundation/distributedhardware/device_manager/sa_profile:device_manager.cfg", - "//foundation/distributedhardware/device_manager/sa_profile:dm_sa_profile" + "//foundation/distributedhardware/device_manager/sa_profile:dm_sa_profile", + "//foundation/distributedhardware/device_manager/permission:permission_json" ] }, "inner_kits": [{ diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h index 50b550689931715da8ee13bc8831e45d13ddf119..515ba44c1bad9e5384749a0389f3159762500155 100755 --- a/common/include/dm_constants.h +++ b/common/include/dm_constants.h @@ -259,6 +259,14 @@ const std::map MAP_ERROR_CODE = { { ERR_DM_AUTH_CODE_INCORRECT, 96929796 }, { ERR_DM_BIND_USER_CANCEL_PIN_CODE_DISPLAY, 96929799 }, { ERR_DM_SYNC_DELETE_DEVICE_REPEATED, 96929801 } }; + +/* Interface Name */ +const std::string IMPORT_AUTHCODE = "ImportAuthCode"; +const std::string EXPORT_AUTHCODE = "ExportAuthCode"; +const std::string REGISTER_PINHOLDER_CALLBACK = "RegisterPinHolderCallback"; +const std::string CREATE_PINHOLDER = "CreatePinHolder"; +const std::string DESTROY_PINHOLDER = "DestroyPinHolder"; +const std::string SET_DNPOLICY = "SetDnPolicy"; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_CONSTANTS_H \ No newline at end of file diff --git a/permission/BUILD.gn b/permission/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..bdee2cc128e88f07378452ceabe0b3608eb83673 --- /dev/null +++ b/permission/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +ohos_prebuilt_etc("permission_json") { + install_enable = true + source = "permission.json" + relative_install_dir = "devicemanager" + part_name = "distributedhardware" + subsystem_name = "device_manager" +} diff --git a/permission/permission.json b/permission/permission.json new file mode 100644 index 0000000000000000000000000000000000000000..5592cb8051a2fcf8594d45938ffb28d926681c73 --- /dev/null +++ b/permission/permission.json @@ -0,0 +1,8 @@ +{ + "ImportAuthCode": ["com.huawei.msdp.hmringgenerator", "com.huawei.msdp.hmringdiscriminator", "CollaborationFwk"], + "ExportAuthCode": ["com.huawei.msdp.hmringgenerator", "com.huawei.msdp.hmringdiscriminator", "CollaborationFwk"], + "RegisterPinHolderCallback": ["CollaborationFwk"], + "CreatePinHolder": ["CollaborationFwk"], + "DestroyPinHolder": ["CollaborationFwk"], + "SetDnPolicy": ["collaboration_service"] +} diff --git a/services/service/include/permission/lite/permission_manager.h b/services/service/include/permission/lite/permission_manager.h index 85b6bd48e40f8c8be777da026549473ac672e97c..94538c44f57daab13a6ff39cfe885640f9bddb8d 100644 --- a/services/service/include/permission/lite/permission_manager.h +++ b/services/service/include/permission/lite/permission_manager.h @@ -26,16 +26,16 @@ class PermissionManager { DM_DECLARE_SINGLE_INSTANCE(PermissionManager); public: + int32_t Init(); + int32_t UnInit(); bool CheckPermission(void); bool CheckNewPermission(void); bool CheckMonitorPermission(void); int32_t GetCallerProcessName(std::string &processName); - bool CheckProcessNameValidOnAuthCode(const std::string &processName); - bool CheckProcessNameValidOnPinHolder(const std::string &processName); bool CheckWhiteListSystemSA(const std::string &pkgName); std::unordered_set GetWhiteListSystemSA(); bool CheckSystemSA(const std::string &pkgName); - bool CheckProcessNameValidOnSetDnPolicy(const std::string &processName); + bool CheckInterfacePermission(const std::string &interfaceName); }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/include/permission/standard/permission_manager.h b/services/service/include/permission/standard/permission_manager.h index ddf790bf0ac202bd41b355de7ac7ccdc27f3c4b8..9a1d84bcb42cefd8176dfec5ecaa1ce056e907b2 100644 --- a/services/service/include/permission/standard/permission_manager.h +++ b/services/service/include/permission/standard/permission_manager.h @@ -16,7 +16,9 @@ #ifndef OHOS_DM_PERMISSION_STANDARD_PERMISSION_MANAGER_H #define OHOS_DM_PERMISSION_STANDARD_PERMISSION_MANAGER_H +#include "cJSON.h" #include +#include #include #include #include "dm_single_instance.h" @@ -27,16 +29,24 @@ class PermissionManager { DM_DECLARE_SINGLE_INSTANCE(PermissionManager); public: + int32_t Init(); + int32_t UnInit(); bool CheckPermission(void); bool CheckNewPermission(void); bool CheckMonitorPermission(void); int32_t GetCallerProcessName(std::string &processName); - bool CheckProcessNameValidOnAuthCode(const std::string &processName); - bool CheckProcessNameValidOnPinHolder(const std::string &processName); bool CheckWhiteListSystemSA(const std::string &pkgName); std::unordered_set GetWhiteListSystemSA(); bool CheckSystemSA(const std::string &pkgName); - bool CheckProcessNameValidOnSetDnPolicy(const std::string &processName); + bool CheckInterfacePermission(const std::string &interfaceName); +private: + int32_t LoadPermissionCfg(const std::string &filePath); + int32_t ParsePermissionJson(const cJSON *const permissionJson); + void SetPermissionMap(const cJSON *const permissionJson, const std::string &interfaceName); + +private: + std::mutex permissionMutex_; + std::unordered_map> permissionMap_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index 0868ce035f396a02f7f5021d85e784b1774b8543..52fa4fb8d29535d373586d2255fc6f0746c57a24 100755 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -241,6 +241,7 @@ int32_t DeviceManagerService::InitDMServiceListener() #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) DMCommTool::GetInstance()->Init(); #endif + PermissionManager::GetInstance().Init(); LOGI("Init success."); return DM_OK; } @@ -253,6 +254,7 @@ void DeviceManagerService::UninitDMServiceListener() #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) KVAdapterManager::GetInstance().UnInit(); #endif + PermissionManager::GetInstance().UnInit(); LOGI("Uninit."); } @@ -1097,13 +1099,8 @@ int32_t DeviceManagerService::ImportAuthCode(const std::string &pkgName, const s LOGE("The caller: %{public}s does not have permission to call ImportAuthCode.", pkgName.c_str()); return ERR_DM_NO_PERMISSION; } - std::string processName = ""; - if (PermissionManager::GetInstance().GetCallerProcessName(processName) != DM_OK) { - LOGE("Get caller process name failed, pkgname: %{public}s.", pkgName.c_str()); - return ERR_DM_FAILED; - } - if (!PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName)) { - LOGE("The caller: %{public}s is not in white list.", processName.c_str()); + if (!PermissionManager::GetInstance().CheckInterfacePermission(IMPORT_AUTHCODE)) { + LOGE("The caller: %{public}s is not in white list.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } LOGI("DeviceManagerService::ImportAuthCode begin."); @@ -1124,13 +1121,8 @@ int32_t DeviceManagerService::ExportAuthCode(std::string &authCode) LOGE("The caller does not have permission to call ExportAuthCode."); return ERR_DM_NO_PERMISSION; } - std::string processName = ""; - if (PermissionManager::GetInstance().GetCallerProcessName(processName) != DM_OK) { - LOGE("Get caller process name failed, processName: %{public}s.", processName.c_str()); - return ERR_DM_FAILED; - } - if (!PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName)) { - LOGE("The caller: %{public}s is not in white list.", processName.c_str()); + if (!PermissionManager::GetInstance().CheckInterfacePermission(EXPORT_AUTHCODE)) { + LOGE("The caller is not in white list."); return ERR_DM_INPUT_PARA_INVALID; } if (!IsDMServiceImplReady()) { @@ -1452,13 +1444,8 @@ int32_t DeviceManagerService::RegisterPinHolderCallback(const std::string &pkgNa LOGE("The caller: %{public}s does not have permission to call ImportAuthCode.", pkgName.c_str()); return ERR_DM_NO_PERMISSION; } - std::string processName = ""; - if (PermissionManager::GetInstance().GetCallerProcessName(processName) != DM_OK) { - LOGE("Get caller process name failed, pkgname: %{public}s.", pkgName.c_str()); - return ERR_DM_FAILED; - } - if (!PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName)) { - LOGE("The caller: %{public}s is not in white list.", processName.c_str()); + if (!PermissionManager::GetInstance().CheckInterfacePermission(REGISTER_PINHOLDER_CALLBACK)) { + LOGE("The caller: %{public}s is not in white list.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } LOGI("DeviceManagerService::RegisterPinHolderCallback begin."); @@ -1477,13 +1464,8 @@ int32_t DeviceManagerService::CreatePinHolder(const std::string &pkgName, const LOGE("The caller: %{public}s does not have permission to call CreatePinHolder.", pkgName.c_str()); return ERR_DM_NO_PERMISSION; } - std::string processName = ""; - if (PermissionManager::GetInstance().GetCallerProcessName(processName) != DM_OK) { - LOGE("Get caller process name failed, pkgname: %{public}s.", pkgName.c_str()); - return ERR_DM_FAILED; - } - if (!PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName)) { - LOGE("The caller: %{public}s is not in white list.", processName.c_str()); + if (!PermissionManager::GetInstance().CheckInterfacePermission(CREATE_PINHOLDER)) { + LOGE("The caller: %{public}s is not in white list.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } LOGI("DeviceManagerService::CreatePinHolder begin."); @@ -1502,13 +1484,8 @@ int32_t DeviceManagerService::DestroyPinHolder(const std::string &pkgName, const LOGE("The caller: %{public}s does not have permission to call DestroyPinHolder.", pkgName.c_str()); return ERR_DM_NO_PERMISSION; } - std::string processName = ""; - if (PermissionManager::GetInstance().GetCallerProcessName(processName) != DM_OK) { - LOGE("Get caller process name failed, pkgname: %{public}s.", pkgName.c_str()); - return ERR_DM_FAILED; - } - if (!PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName)) { - LOGE("The caller: %{public}s is not in white list.", processName.c_str()); + if (!PermissionManager::GetInstance().CheckInterfacePermission(DESTROY_PINHOLDER)) { + LOGE("The caller: %{public}s is not in white list.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } LOGI("Begin."); @@ -1956,13 +1933,8 @@ int32_t DeviceManagerService::SetDnPolicy(const std::string &pkgName, std::map PermissionManager::GetWhiteListSystemSA() { - (void)processName; - return true; + return std::unordered_set{}; } -bool PermissionManager::CheckWhiteListSystemSA(const std::string &pkgName) +bool PermissionManager::CheckSystemSA(const std::string &pkgName) { (void)pkgName; return true; } -std::unordered_set PermissionManager::GetWhiteListSystemSA() +int32_t PermissionManager::Init() { - return std::unordered_set{}; + return DM_OK; } -bool PermissionManager::CheckSystemSA(const std::string &pkgName) +int32_t PermissionManager::UnInit() { - (void)pkgName; - return true; + return DM_OK; } -bool PermissionManager::CheckProcessNameValidOnSetDnPolicy(const std::string &processName) +bool PermissionManager::CheckInterfacePermission(const std::string &interfaceName) { - (void)processName; + (void)interfaceName; return true; } } // namespace DistributedHardware diff --git a/services/service/src/permission/standard/permission_manager.cpp b/services/service/src/permission/standard/permission_manager.cpp index 971d0da127c558c884f470e4b0ec8925183d474b..58cd56a3a2777b0824920bc60ad99e3cf5bd32d7 100644 --- a/services/service/src/permission/standard/permission_manager.cpp +++ b/services/service/src/permission/standard/permission_manager.cpp @@ -15,10 +15,14 @@ #include "permission_manager.h" +#include + #include "accesstoken_kit.h" #include "access_token.h" #include "dm_anonymous.h" +#include "dm_constants.h" #include "dm_log.h" +#include "file_ex.h" #include "hap_token_info.h" #include "ipc_skeleton.h" #include "native_token_info.h" @@ -34,23 +38,10 @@ namespace { constexpr const char* DM_SERVICE_ACCESS_PERMISSION = "ohos.permission.ACCESS_SERVICE_DM"; constexpr const char* DM_SERVICE_ACCESS_NEWPERMISSION = "ohos.permission.DISTRIBUTED_DATASYNC"; constexpr const char* DM_MONITOR_DEVICE_NETWORK_STATE_PERMISSION = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE"; -constexpr int32_t DM_OK = 0; -constexpr int32_t ERR_DM_FAILED = 96929744; constexpr int32_t PKG_NAME_SIZE_MAX = 256; -constexpr int32_t AUTH_CODE_WHITE_LIST_NUM = 3; -constexpr const static char g_authCodeWhiteList[AUTH_CODE_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { - "com.huawei.msdp.hmringgenerator", - "com.huawei.msdp.hmringdiscriminator", - "CollaborationFwk", -}; - -constexpr int32_t PIN_HOLDER_WHITE_LIST_NUM = 1; -constexpr const static char g_pinHolderWhiteList[PIN_HOLDER_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { - "CollaborationFwk", -}; constexpr int32_t SYSTEM_SA_WHITE_LIST_NUM = 7; -constexpr const static char systemSaWhiteList[SYSTEM_SA_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { +constexpr const static char SYSTEM_SA_WHITE_LIST[SYSTEM_SA_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { "Samgr_Networking", "ohos.distributeddata.service", "ohos.dslm", @@ -59,11 +50,121 @@ constexpr const static char systemSaWhiteList[SYSTEM_SA_WHITE_LIST_NUM][PKG_NAME "ohos.dhardware", "ohos.security.distributed_access_token", }; +const std::string PERMISSION_JSON_PATH = "/system/etc/devicemanager/permission.json"; +const std::string ALL_PROC = "all"; +constexpr int32_t MAX_INTERFACE_SIZE = 20; +} -constexpr uint32_t SETDNPOLICY_WHITE_LIST_NUM = 1; -constexpr const static char g_setDnPolicyWhiteList[SETDNPOLICY_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { - "collaboration_service", -}; +int32_t PermissionManager::Init() +{ + LOGI("call!"); + if (!LoadPermissionCfg(PERMISSION_JSON_PATH)) { + return ERR_DM_FAILED; + } + LOGI("init succeeded"); + return DM_OK; +} + +int32_t PermissionManager::UnInit() +{ + LOGI("UnInit"); + std::lock_guard autoLock(permissionMutex_); + permissionMap_.clear(); + return DM_OK; +} + +int32_t PermissionManager::LoadPermissionCfg(const std::string &filePath) +{ + char path[PATH_MAX + 1] = {0x00}; + if (filePath.length() == 0 || filePath.length() > PATH_MAX) { + LOGE("File canonicalization failed"); + return ERR_DM_FAILED; + } + size_t ret = readlink(filePath.c_str(), path, PATH_MAX); + if (ret == -1 || static_cast(ret) >= PATH_MAX) { + LOGE("path too long"); + return ERR_DM_FAILED; + } + std::ifstream ifs(path); + if (!ifs.is_open()) { + LOGE("load json file failed"); + return ERR_DM_FAILED; + } + std::string fileContent(std::istreambuf_iterator{ifs}, std::istreambuf_iterator{}); + ifs.close(); + + cJSON *permissionJson = cJSON_Parse(fileContent.c_str()); + if (!cJSON_IsObject(permissionJson)) { + LOGE("Permission json parse failed!"); + cJSON_Delete(permissionJson); + return ERR_DM_FAILED; + } + int32_t parseResult = ParsePermissionJson(permissionJson); + LOGI("permission json load result %{public}d!", parseResult); + cJSON_Delete(permissionJson); + return parseResult; +} + +int32_t PermissionManager::ParsePermissionJson(const cJSON *const permissionJson) +{ + int size = cJSON_GetArraySize(permissionJson); + if (size == 0 || size > MAX_INTERFACE_SIZE) { + LOGE("Permission json size is invalid!size: %{public}d!", size); + return ERR_DM_FAILED; + } + SetPermissionMap(permissionJson, IMPORT_AUTHCODE); + SetPermissionMap(permissionJson, EXPORT_AUTHCODE); + SetPermissionMap(permissionJson, REGISTER_PINHOLDER_CALLBACK); + SetPermissionMap(permissionJson, CREATE_PINHOLDER); + SetPermissionMap(permissionJson, DESTROY_PINHOLDER); + SetPermissionMap(permissionJson, SET_DNPOLICY); + char *jsonChars = cJSON_PrintUnformatted(permissionJson); + if (jsonChars == NULL) { + LOGW("cJSON formatted to string failed!"); + } else { + LOGD("permission json %{public}s parse success!", jsonChars); + cJSON_free(jsonChars); + } + return DM_OK; +} + +void PermissionManager::SetPermissionMap(const cJSON *const permissionJson, const std::string& interfaceName) +{ + cJSON *item = cJSON_GetObjectItem(permissionJson, interfaceName.c_str()); + int32_t itemSize = static_cast(cJSON_GetArraySize(item)); + if (!cJSON_IsArray(item) || itemSize == 0 || itemSize > MAX_INTERFACE_SIZE) { + LOGE("PermissionJson not contains the key, %{public}s!", interfaceName.c_str()); + return; + } + std::unordered_set interfaceNameSets; + item = item->child; + while (item != NULL) { + if (cJSON_IsString(item)) { + interfaceNameSets.emplace(item->valuestring); + } + item = item->next; + } + { + std::lock_guard autoLock(permissionMutex_); + permissionMap_[interfaceName] = interfaceNameSets; + } +} + +bool PermissionManager::CheckInterfacePermission(const std::string &interfaceName) +{ + std::string callProcName = ""; + if (GetCallerProcessName(callProcName) != DM_OK) { + LOGE("Get caller process name failed"); + return false; + } + std::unordered_set permittedProcNames; + { + std::lock_guard autoLock(permissionMutex_); + permittedProcNames = permissionMap_[interfaceName]; + } + bool checkResult = (permittedProcNames.count(callProcName) != 0 || permittedProcNames.count(ALL_PROC) != 0); + LOGD("success interface %{public}s callProc %{public}s!", interfaceName.c_str(), callProcName.c_str()); + return checkResult; } bool PermissionManager::CheckPermission(void) @@ -157,50 +258,10 @@ int32_t PermissionManager::GetCallerProcessName(std::string &processName) return DM_OK; } -bool PermissionManager::CheckProcessNameValidOnAuthCode(const std::string &processName) -{ - LOGI("Enter PermissionManager::CheckProcessNameValidOnAuthCode"); - if (processName.empty()) { - LOGE("ProcessName is empty"); - return false; - } - - uint16_t index = 0; - for (; index < AUTH_CODE_WHITE_LIST_NUM; ++index) { - std::string tmp(g_authCodeWhiteList[index]); - if (processName == tmp) { - return true; - } - } - - LOGE("CheckProcessNameValidOnAuthCode process name: %{public}s invalid.", processName.c_str()); - return false; -} - -bool PermissionManager::CheckProcessNameValidOnPinHolder(const std::string &processName) -{ - LOGI("Enter PermissionManager::CheckProcessNameValidOnPinHolder"); - if (processName.empty()) { - LOGE("ProcessName is empty"); - return false; - } - - uint16_t index = 0; - for (; index < PIN_HOLDER_WHITE_LIST_NUM; ++index) { - std::string tmp(g_pinHolderWhiteList[index]); - if (processName == tmp) { - return true; - } - } - - LOGE("CheckProcessNameValidOnPinHolder process name: %{public}s invalid.", processName.c_str()); - return false; -} - bool PermissionManager::CheckWhiteListSystemSA(const std::string &pkgName) { for (uint16_t index = 0; index < SYSTEM_SA_WHITE_LIST_NUM; ++index) { - std::string tmp(systemSaWhiteList[index]); + std::string tmp(SYSTEM_SA_WHITE_LIST[index]); if (pkgName == tmp) { return true; } @@ -212,7 +273,7 @@ std::unordered_set PermissionManager::GetWhiteListSystemSA() { std::unordered_set systemSA; for (uint16_t index = 0; index < SYSTEM_SA_WHITE_LIST_NUM; ++index) { - std::string tmp(systemSaWhiteList[index]); + std::string tmp(SYSTEM_SA_WHITE_LIST[index]); systemSA.insert(tmp); } return systemSA; @@ -231,23 +292,5 @@ bool PermissionManager::CheckSystemSA(const std::string &pkgName) } return false; } - -bool PermissionManager::CheckProcessNameValidOnSetDnPolicy(const std::string &processName) -{ - if (processName.empty()) { - LOGE("ProcessName is empty"); - return false; - } - uint16_t index = 0; - for (; index < SETDNPOLICY_WHITE_LIST_NUM; ++index) { - std::string tmp(g_setDnPolicyWhiteList[index]); - if (processName == tmp) { - return true; - } - } - - LOGE("Process name: %{public}s invalid.", processName.c_str()); - return false; -} } // namespace DistributedHardware } // namespace OHOS diff --git a/test/commonunittest/UTTest_permission_manager.cpp b/test/commonunittest/UTTest_permission_manager.cpp index 4e0e13bf84dd31313d56d31391cf1b74134eb4a6..4c44794cca38f2377e5257b85bfcc6e27661f1d0 100644 --- a/test/commonunittest/UTTest_permission_manager.cpp +++ b/test/commonunittest/UTTest_permission_manager.cpp @@ -44,17 +44,6 @@ void PermissionManagerTest::SetUp() OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); } constexpr int32_t PAKAGE_NAME_SIZE_MAX = 256; -#define AUTH_CODE_WHITE_LIST_NUM (3) -constexpr const static char g_authCodeWhiteList[AUTH_CODE_WHITE_LIST_NUM][PAKAGE_NAME_SIZE_MAX] = { - "com.huawei.msdp.hmringgenerator", - "com.huawei.msdp.hmringdiscriminator", - "CollaborationFwk", -}; - -#define PIN_HOLDER_WHITE_LIST_NUM (1) -constexpr const static char g_pinHolderWhiteList[PIN_HOLDER_WHITE_LIST_NUM][PKG_NAME_SIZE_MAX] = { - "CollaborationFwk", -}; #define SYSTEM_SA_WHITE_LIST_NUM (4) constexpr const static char systemSaWhiteList[SYSTEM_SA_WHITE_LIST_NUM][PAKAGE_NAME_SIZE_MAX] = { @@ -63,6 +52,7 @@ constexpr const static char systemSaWhiteList[SYSTEM_SA_WHITE_LIST_NUM][PAKAGE_N "ohos.dslm", "ohos.deviceprofile", }; + void PermissionManagerTest::TearDown() { } @@ -102,102 +92,6 @@ HWTEST_F(PermissionManagerTest, GetCallerProcessName_001, testing::ext::TestSize ASSERT_EQ(ret, DM_OK); } -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_001 - * @tc.desc: the return value is false - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_001, testing::ext::TestSize.Level0) -{ - std::string processName; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName); - ASSERT_EQ(ret, false); -} - -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_002 - * @tc.desc: the return value is false - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_002, testing::ext::TestSize.Level0) -{ - std::string processName = "processName"; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName); - ASSERT_EQ(ret, false); -} - -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnAuthCode_003 - * @tc.desc: the return value is true - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_003, testing::ext::TestSize.Level0) -{ - std::string processName1(g_authCodeWhiteList[0]); - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName1); - ASSERT_EQ(ret, true); - std::string processName2(g_authCodeWhiteList[1]); - ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName2); - ASSERT_EQ(ret, true); - std::string processName3(g_authCodeWhiteList[2]); - ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName3); - ASSERT_EQ(ret, true); -} - -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnAuthCode_004, testing::ext::TestSize.Level0) -{ - std::string processName = "CollaborationFwk"; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnAuthCode(processName); - ASSERT_TRUE(ret); -} -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_001 - * @tc.desc: the return value is false - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_001, testing::ext::TestSize.Level0) -{ - std::string processName; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName); - ASSERT_EQ(ret, false); -} - -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_002 - * @tc.desc: the return value is false - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_002, testing::ext::TestSize.Level0) -{ - std::string processName = "processName"; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName); - ASSERT_EQ(ret, false); -} - -/** - * @tc.name: PinAuthUi::CheckProcessNameValidOnPinHolder_003 - * @tc.desc: the return value is true - * @tc.type: FUNC - * @tc.require: AR000GHSJK - */ -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_003, testing::ext::TestSize.Level0) -{ - std::string processName1(g_pinHolderWhiteList[0]); - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName1); - ASSERT_EQ(ret, true); -} - -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_004, testing::ext::TestSize.Level0) -{ - std::string processName = "CollaborationFwk"; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnPinHolder(processName); - ASSERT_TRUE(ret); -} /** * @tc.name: PinAuthUi::CheckWhiteListSystemSA_001 * @tc.desc: the return value is false @@ -255,21 +149,6 @@ HWTEST_F(PermissionManagerTest, CheckMonitorPermission_001, testing::ext::TestSi bool ret = PermissionManager::GetInstance().CheckMonitorPermission(); ASSERT_FALSE(ret); } - -HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnSetDnPolicy_001, testing::ext::TestSize.Level0) -{ - std::string processName = ""; - bool ret = PermissionManager::GetInstance().CheckProcessNameValidOnSetDnPolicy(processName); - ASSERT_FALSE(ret); - - processName = "processName"; - ret = PermissionManager::GetInstance().CheckProcessNameValidOnSetDnPolicy(processName); - ASSERT_FALSE(ret); - - processName = "collaboration_service"; - ret = PermissionManager::GetInstance().CheckProcessNameValidOnSetDnPolicy(processName); - ASSERT_TRUE(ret); -} } } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 3d05e0581cb31428eceac4af005d5713221e659c..3a2921c31e49c354ead9b05879ccb182e36acd9e 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -920,6 +920,7 @@ ohos_unittest("UTTest_permission_manager") { "access_token:libaccesstoken_sdk", "access_token:libnativetoken", "access_token:libtoken_setproc", + "cJSON:cjson", "device_auth:deviceauth_sdk", "googletest:gmock", ] diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp index cee773b829c2d82eef60cd5f58b52f9791d4bc3c..22e8c8999ef67abc8b93d26ffb367fe8eab999c4 100644 --- a/test/unittest/UTTest_device_manager_service.cpp +++ b/test/unittest/UTTest_device_manager_service.cpp @@ -1618,8 +1618,7 @@ HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_002, testing::ext::TestSize.Le { std::string pkgName = "pkgName"; std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -1635,8 +1634,7 @@ HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_001, testing::ext::TestSize.Le HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_002, testing::ext::TestSize.Level0) { std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -1967,8 +1965,7 @@ HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_001, testing::ext:: HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_002, testing::ext::TestSize.Level0) { std::string pkgName = "pkgName"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName); EXPECT_NE(ret, DM_OK); } @@ -1990,8 +1987,7 @@ HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_002, testing::ext::TestSize.L PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2013,8 +2009,7 @@ HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_002, testing::ext::TestSize. PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2182,8 +2177,7 @@ HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_003, testing::ext::TestSize. PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2391,8 +2385,7 @@ HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_004, testing::ext::TestSize. PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2403,8 +2396,7 @@ HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_005, testing::ext::TestSize. PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) { DeviceManagerService::GetInstance().InitDMServiceListener(); } @@ -2418,8 +2410,7 @@ HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_003, testing::ext::TestSize.L PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2430,8 +2421,7 @@ HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_004, testing::ext::TestSize.L PeerTargetId targetId; DmPinType pinType = DmPinType::QR_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) { DeviceManagerService::GetInstance().InitDMServiceListener(); } @@ -2442,8 +2432,7 @@ HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_004, testing::ext::TestSize.L HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_003, testing::ext::TestSize.Level0) { std::string pkgName; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2451,8 +2440,7 @@ HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_003, testing::ext:: HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_004, testing::ext::TestSize.Level0) { std::string pkgName = "pkgName"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) { DeviceManagerService::GetInstance().InitDMServiceListener(); } @@ -2482,8 +2470,7 @@ HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_003, testing::ext::TestSize.Le { std::string pkgName = "pkgName"; std::string authCode; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -2492,8 +2479,7 @@ HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_004, testing::ext::TestSize.Le { std::string pkgName = "pkgName"; std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); EXPECT_EQ(ret, DM_OK); } @@ -2501,8 +2487,7 @@ HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_004, testing::ext::TestSize.Le HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_003, testing::ext::TestSize.Level0) { std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode); EXPECT_EQ(ret, DM_OK); } diff --git a/test/unittest/UTTest_device_manager_service_three.cpp b/test/unittest/UTTest_device_manager_service_three.cpp index 77a8e4bf9f995ed1496a07a9bcd520b028029a2e..599463f8138be6f2360b584909b14bf3ae5bfcca 100644 --- a/test/unittest/UTTest_device_manager_service_three.cpp +++ b/test/unittest/UTTest_device_manager_service_three.cpp @@ -345,8 +345,7 @@ HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_301, testing::ext::TestSi { std::string pkgName = "pkgName"; std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); EXPECT_EQ(ret, ERR_DM_NOT_INIT); @@ -364,8 +363,7 @@ HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_301, testing::ext::TestSi HWTEST_F(DeviceManagerServiceThreeTest, ExportAuthCode_301, testing::ext::TestSize.Level0) { std::string authCode = "authCode"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(true)); EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode); EXPECT_EQ(ret, ERR_DM_NOT_INIT); diff --git a/test/unittest/UTTest_device_manager_service_two.cpp b/test/unittest/UTTest_device_manager_service_two.cpp index 5212e8a5e8fb92d97f884573373803c165a937f9..81dee5d50374cb3167a3fd3044932b296d58c9d0 100644 --- a/test/unittest/UTTest_device_manager_service_two.cpp +++ b/test/unittest/UTTest_device_manager_service_two.cpp @@ -168,8 +168,7 @@ HWTEST_F(DeviceManagerServiceTest, IsDMImplSoLoaded_201, testing::ext::TestSize. HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_201, testing::ext::TestSize.Level0) { std::string pkgName = "CollaborationFwk"; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -184,8 +183,8 @@ HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_201, testing::ext::TestSize.L PeerTargetId targetId; DmPinType pinType = NUMBER_PIN_CODE; std::string payload; - EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).Times(::testing::AtLeast(1)).WillOnce(Return(false)); + EXPECT_CALL(*permissionManagerMock_, CheckInterfacePermission(_)). + Times(::testing::AtLeast(1)).WillOnce(Return(false)); int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } diff --git a/test/unittest/mock/permission_manager_mock.cpp b/test/unittest/mock/permission_manager_mock.cpp index df84d7a83949602f527e99583a7b5f30e249b5cb..c596d17f36bdaa88d294442e5cea96c9c3189297 100644 --- a/test/unittest/mock/permission_manager_mock.cpp +++ b/test/unittest/mock/permission_manager_mock.cpp @@ -20,14 +20,9 @@ namespace OHOS { namespace DistributedHardware { DM_IMPLEMENT_SINGLE_INSTANCE(PermissionManager); -bool PermissionManager::CheckProcessNameValidOnPinHolder(const std::string &processName) +bool PermissionManager::CheckInterfacePermission(const std::string &interfaceName) { - return DmPermissionManager::dmPermissionManager->CheckProcessNameValidOnPinHolder(processName); -} - -bool PermissionManager::CheckProcessNameValidOnAuthCode(const std::string &processName) -{ - return DmPermissionManager::dmPermissionManager->CheckProcessNameValidOnAuthCode(processName); + return DmPermissionManager::dmPermissionManager->CheckInterfacePermission(interfaceName); } int32_t PermissionManager::GetCallerProcessName(std::string &processName) diff --git a/test/unittest/mock/permission_manager_mock.h b/test/unittest/mock/permission_manager_mock.h index b5c061e69b7ad9f1fd3b4e3f811e25edd9c4a839..7ecd7410b338c78d287ef3e69a113fd01938354d 100644 --- a/test/unittest/mock/permission_manager_mock.h +++ b/test/unittest/mock/permission_manager_mock.h @@ -26,8 +26,7 @@ class DmPermissionManager { public: virtual ~DmPermissionManager() = default; public: - virtual bool CheckProcessNameValidOnPinHolder(const std::string &processName) = 0; - virtual bool CheckProcessNameValidOnAuthCode(const std::string &processName) = 0; + virtual bool CheckInterfacePermission(const std::string &interfaceName) = 0; virtual int32_t GetCallerProcessName(std::string &processName) = 0; public: static inline std::shared_ptr dmPermissionManager = nullptr; @@ -35,8 +34,7 @@ public: class PermissionManagerMock : public DmPermissionManager { public: - MOCK_METHOD(bool, CheckProcessNameValidOnPinHolder, (const std::string &)); - MOCK_METHOD(bool, CheckProcessNameValidOnAuthCode, (const std::string &)); + MOCK_METHOD(bool, CheckInterfacePermission, (const std::string &)); MOCK_METHOD(int32_t, GetCallerProcessName, (std::string &)); }; }