From 3ba84824e54680a2dd26b9513331fde59cd1426a Mon Sep 17 00:00:00 2001 From: zhangyuhang72 Date: Thu, 20 Mar 2025 10:34:01 +0800 Subject: [PATCH] =?UTF-8?q?Extension=E9=BB=91=E7=99=BD=E5=90=8D=E5=8D=95?= =?UTF-8?q?=E7=AE=A1=E6=8E=A7=E5=A2=9E=E5=BC=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhangyuhang72 Change-Id: I415e64c9921de67ff8dcd19b2c5b32f4f8eb5b2c --- .../ability_business_error.cpp | 4 + .../include/ability_manager_errors.h | 5 + .../ability_business_error.h | 3 + .../abilitymgr/include/extension_config.h | 31 +- .../extension_control_interceptor.h | 4 + services/abilitymgr/src/extension_config.cpp | 201 ++- .../extension_control_interceptor.cpp | 55 +- services/common/include/json_utils.h | 10 + services/common/src/json_utils.cpp | 8 + test/fuzztest/extensionconfig_fuzzer/BUILD.gn | 1 + .../extensionconfig_fuzzer.cpp | 10 +- .../ability_extension_config_test/BUILD.gn | 1 + .../ability_extension_config_test.cpp | 1124 ++++++++++++++++- 13 files changed, 1388 insertions(+), 69 deletions(-) diff --git a/frameworks/native/ability/native/ability_business_error/ability_business_error.cpp b/frameworks/native/ability/native/ability_business_error/ability_business_error.cpp index 3686483fb0..d355ef46ee 100644 --- a/frameworks/native/ability/native/ability_business_error/ability_business_error.cpp +++ b/frameworks/native/ability/native/ability_business_error/ability_business_error.cpp @@ -100,6 +100,8 @@ constexpr const char* ERROR_MSG_UPPER_LIMIT = "The number of app instances reach constexpr const char* ERROR_MSG_APP_INSTANCE_KEY_NOT_SUPPORT = "The APP_INSTANCE_KEY cannot be specified."; constexpr const char* ERROR_MSG_CREATE_NEW_INSTANCE_NOT_SUPPORT = "Creating a new instance is not supported."; constexpr const char* ERROR_MSG_UI_ABILITY_IS_STARTING = "The UIAbility is being started."; +constexpr const char* ERROR_MSG_EXTENSION_START_ABILITY_CONTROLLED = + "The extension can not start the ability due to extension control."; // follow ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST of appexecfwk_errors.h in bundle_framework constexpr int32_t ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST = 8521220; @@ -172,6 +174,7 @@ static std::unordered_map ERR_CODE_MAP = { { AbilityErrorCode::ERROR_CODE_APP_INSTANCE_KEY_NOT_SUPPORT, ERROR_MSG_APP_INSTANCE_KEY_NOT_SUPPORT }, { AbilityErrorCode::ERROR_CODE_CREATE_NEW_INSTANCE_NOT_SUPPORT, ERROR_MSG_CREATE_NEW_INSTANCE_NOT_SUPPORT }, { AbilityErrorCode::ERROR_CODE_UI_ABILITY_IS_STARTING, ERROR_MSG_UI_ABILITY_IS_STARTING}, + { AbilityErrorCode::ERROR_CODE_EXTENSION_START_ABILITY_CONTROLLED, ERROR_MSG_EXTENSION_START_ABILITY_CONTROLLED }, }; static std::unordered_map INNER_TO_JS_ERROR_CODE_MAP { @@ -247,6 +250,7 @@ static std::unordered_map INNER_TO_JS_ERROR_CODE_MAP {ERR_APP_INSTANCE_KEY_NOT_SUPPORT, AbilityErrorCode::ERROR_CODE_APP_INSTANCE_KEY_NOT_SUPPORT}, {ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT, AbilityErrorCode::ERROR_CODE_CREATE_NEW_INSTANCE_NOT_SUPPORT}, {ERR_UI_ABILITY_IS_STARTING, AbilityErrorCode::ERROR_CODE_UI_ABILITY_IS_STARTING}, + {ERR_EXTENSION_START_ABILITY_CONTROLEED, AbilityErrorCode::ERROR_CODE_EXTENSION_START_ABILITY_CONTROLLED}, }; } diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_errors.h b/interfaces/inner_api/ability_manager/include/ability_manager_errors.h index 5e4beb2292..e3636bbc6a 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_errors.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_errors.h @@ -703,6 +703,11 @@ enum { ERR_NULL_APP_MGR_PROXY = 2097303, ERR_NO_APP_RECORD = 2097304, + /* + * Result(2097305) for extension starting ability controlled + */ + ERR_EXTENSION_START_ABILITY_CONTROLEED = 2097305, + /** * Native error(3000000) for target bundle not exist. */ diff --git a/interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h b/interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h index e065e24909..e3feb13dbc 100644 --- a/interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h +++ b/interfaces/kits/native/ability/native/ability_business_error/ability_business_error.h @@ -183,6 +183,9 @@ enum class AbilityErrorCode { // UIAbility is in starting state. ERROR_CODE_UI_ABILITY_IS_STARTING = 16000082, + // extension can not start the ability due to extension control. + ERROR_CODE_EXTENSION_START_ABILITY_CONTROLLED = 16000083, + // invalid caller. ERROR_CODE_INVALID_CALLER = 16200001, diff --git a/services/abilitymgr/include/extension_config.h b/services/abilitymgr/include/extension_config.h index 64f925ae9f..9ff548ee9e 100644 --- a/services/abilitymgr/include/extension_config.h +++ b/services/abilitymgr/include/extension_config.h @@ -19,6 +19,7 @@ #include #include #include +#include #include #include @@ -33,6 +34,14 @@ constexpr static bool EXTENSION_SA_ENABLE_FLAG_DEFAULT = true; constexpr static bool EXTENSION_THIRD_PARTY_APP_ENABLE_FLAG_DEFAULT = true; constexpr static bool EXTENSION_START_SERVICE_ENABLE_FLAG_DEFAULT = true; +struct AbilityAccessItem { + std::optional thirdPartyAppAccessFlag = std::nullopt; + std::optional serviceAccessFlag = std::nullopt; + std::optional defaultAccessFlag = std::nullopt; + std::unordered_set blockList; + std::unordered_set allowList; +}; + struct ExtensionConfigItem { bool networkEnableFlag = EXTENSION_NETWORK_ENABLE_FLAG_DEFAULT; bool saEnableFlag = EXTENSION_SA_ENABLE_FLAG_DEFAULT; @@ -40,6 +49,8 @@ struct ExtensionConfigItem { bool serviceEnableFlag = EXTENSION_START_SERVICE_ENABLE_FLAG_DEFAULT; int32_t extensionAutoDisconnectTime = DEFAULT_EXTENSION_AUTO_DISCONNECT_TIME; std::unordered_set serviceBlockedList; + AbilityAccessItem abilityAccess; + bool hasAbilityAccess = false; }; class ExtensionConfig : public DelayedSingleton { @@ -50,6 +61,13 @@ public: int32_t GetExtensionAutoDisconnectTime(const std::string &extensionTypeName); bool IsExtensionStartThirdPartyAppEnable(const std::string &extensionTypeName); bool IsExtensionStartServiceEnable(const std::string &extensionTypeName, const std::string &targetUri); + bool HasAbilityAccess(const std::string &extensionTypeName); + bool HasThridPartyAppAccessFlag(const std::string &extensionTypeName); + bool HasServiceAccessFlag(const std::string &extensionTypeName); + bool HasDefaultAccessFlag(const std::string &extensionTypeName); + bool IsExtensionStartThirdPartyAppEnableNew(const std::string &extensionTypeName, const std::string &targetUri); + bool IsExtensionStartServiceEnableNew(const std::string &extensionTypeName, const std::string &targetUri); + bool IsExtensionStartDefaultEnable(const std::string &extensionTypeName, const std::string &targetUri); bool IsExtensionNetworkEnable(const std::string &extensionTypeName); bool IsExtensionSAEnable(const std::string &extensionTypeName); private: @@ -57,13 +75,22 @@ private: bool ReadFileInfoJson(const std::string &filePath, nlohmann::json &jsonBuf); std::string GetExtensionConfigPath() const; - void LoadExtensionAutoDisconnectTime(const nlohmann::json &object, std::string extensionTypeName); + void LoadExtensionAutoDisconnectTime(const nlohmann::json &object, const std::string &extensionTypeName); void LoadExtensionThirdPartyAppBlockedList(const nlohmann::json &object, std::string extensionTypeName); void LoadExtensionServiceBlockedList(const nlohmann::json &object, std::string extensionTypeNameobject); void LoadExtensionNetworkEnable(const nlohmann::json &object, const std::string &extensionTypeName); void LoadExtensionSAEnable(const nlohmann::json &object, const std::string &extensionTypeName); + bool LoadExtensionAbilityAccess(const nlohmann::json &object, const std::string &extensionTypeName); + void LoadExtensionAllowOrBlockedList(const nlohmann::json &object, const std::string &key, + std::unordered_set &list); - bool CheckServiceExtensionUriValid(const std::string &uri); + std::optional GetSingleAccessFlag(const std::string &extensionTypeName, + std::function(const AbilityAccessItem&)> getAccessFlag); + bool IsExtensionAbilityAccessEnable(const std::string &extensionTypeName, const std::string &targetUri, + std::function(const AbilityAccessItem&)> getAccessFlag); + bool FindTargetUriInList(const AppExecFwk::ElementName &targetElementName, std::unordered_set &list); + std::string FormatAccessFlag(const std::optional &flag); + bool CheckExtensionUriValid(const std::string &uri); std::unordered_map configMap_; std::mutex configMapMutex_; diff --git a/services/abilitymgr/include/interceptor/extension_control_interceptor.h b/services/abilitymgr/include/interceptor/extension_control_interceptor.h index 0586345e77..77a99a127b 100644 --- a/services/abilitymgr/include/interceptor/extension_control_interceptor.h +++ b/services/abilitymgr/include/interceptor/extension_control_interceptor.h @@ -34,6 +34,10 @@ private: AppExecFwk::AbilityInfo& callerAbilityInfo); bool GetTargetAbilityInfo(const AbilityInterceptorParam& param, AppExecFwk::AbilityInfo& callerAbilityInfo); + int32_t ProcessInterceptOld(const AbilityInterceptorParam& param, + const AppExecFwk::AbilityInfo &targetAbilityInfo, const AppExecFwk::AbilityInfo &callerAbilityInfo); + int32_t ProcessInterceptNew(const AbilityInterceptorParam& param, + const AppExecFwk::AbilityInfo &targetAbilityInfo, const AppExecFwk::AbilityInfo &callerAbilityInfo); }; } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/extension_config.cpp b/services/abilitymgr/src/extension_config.cpp index 8b98334799..2ced894ada 100644 --- a/services/abilitymgr/src/extension_config.cpp +++ b/services/abilitymgr/src/extension_config.cpp @@ -19,6 +19,7 @@ #include "config_policy_utils.h" #include "hilog_tag_wrapper.h" +#include "json_utils.h" namespace OHOS { namespace AAFwk { @@ -30,11 +31,20 @@ constexpr const char* EXTENSION_CONFIG_NAME = "ams_extension_config"; constexpr const char* EXTENSION_TYPE_NAME = "extension_type_name"; constexpr const char* EXTENSION_AUTO_DISCONNECT_TIME = "auto_disconnect_time"; +// old access flag, deprecated constexpr const char* EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME = "third_party_app_blocked_flag"; constexpr const char* EXTENSION_SERVICE_BLOCKED_LIST_NAME = "service_blocked_list"; constexpr const char* EXTENSION_SERVICE_STARTUP_ENABLE_FLAG = "service_startup_enable_flag"; -constexpr const char* EXTENSION_NETWORK_ENABLE_FLAG = "network_access_enable_flag"; -constexpr const char* EXTENSION_SA_ENABLE_FLAG = "sa_access_enable_flag"; + +// new access flag +constexpr const char* ABILITY_ACCESS = "ability_access"; +constexpr const char* THIRD_PARTY_APP_ACCESS_FLAG = "third_party_app_access_flag"; +constexpr const char* SERVICE_ACCESS_FLAG = "service_access_flag"; +constexpr const char* DEFAULT_ACCESS_FLAG = "default_access_flag"; +constexpr const char* BLOCK_LIST = "blocklist"; +constexpr const char* ALLOW_LIST = "allowlist"; +constexpr const char* NETWORK_ACCESS_ENABLE_FLAG = "network_access_enable_flag"; +constexpr const char* SA_ACCESS_ENABLE_FLAG = "sa_access_enable_flag"; } std::string ExtensionConfig::GetExtensionConfigPath() const @@ -115,14 +125,18 @@ void ExtensionConfig::LoadExtensionConfig(const nlohmann::json &object) std::lock_guard lock(configMapMutex_); std::string extensionTypeName = jsonObject.at(EXTENSION_TYPE_NAME).get(); LoadExtensionAutoDisconnectTime(jsonObject, extensionTypeName); - LoadExtensionThirdPartyAppBlockedList(jsonObject, extensionTypeName); - LoadExtensionServiceBlockedList(jsonObject, extensionTypeName); + bool hasAbilityAccess = LoadExtensionAbilityAccess(jsonObject, extensionTypeName); + if (!hasAbilityAccess) { + LoadExtensionThirdPartyAppBlockedList(jsonObject, extensionTypeName); + LoadExtensionServiceBlockedList(jsonObject, extensionTypeName); + } LoadExtensionNetworkEnable(jsonObject, extensionTypeName); LoadExtensionSAEnable(jsonObject, extensionTypeName); } } -void ExtensionConfig::LoadExtensionAutoDisconnectTime(const nlohmann::json &object, std::string extensionTypeName) +void ExtensionConfig::LoadExtensionAutoDisconnectTime(const nlohmann::json &object, + const std::string &extensionTypeName) { if (!object.contains(EXTENSION_AUTO_DISCONNECT_TIME) || !object.at(EXTENSION_AUTO_DISCONNECT_TIME).is_number()) { @@ -174,7 +188,7 @@ void ExtensionConfig::LoadExtensionServiceBlockedList(const nlohmann::json &obje continue; } std::string serviceUri = jsonObject.get(); - if (CheckServiceExtensionUriValid(serviceUri)) { + if (CheckExtensionUriValid(serviceUri)) { serviceBlockedList.emplace(serviceUri); } } @@ -183,15 +197,72 @@ void ExtensionConfig::LoadExtensionServiceBlockedList(const nlohmann::json &obje extensionTypeName.c_str(), serviceBlockedList.size()); } +bool ExtensionConfig::LoadExtensionAbilityAccess(const nlohmann::json &object, const std::string &extensionTypeName) +{ + TAG_LOGD(AAFwkTag::ABILITYMGR, "call."); + if (!object.contains(ABILITY_ACCESS) || !object.at(ABILITY_ACCESS).is_object()) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "parse ability_access failed"); + configMap_[extensionTypeName].hasAbilityAccess = false; + return false; + } + + configMap_[extensionTypeName].hasAbilityAccess = true; + const nlohmann::json &accessJson = object.at(ABILITY_ACCESS); + auto &abilityAccess = configMap_[extensionTypeName].abilityAccess; + auto &jsonUtils = JsonUtils::GetInstance(); + abilityAccess.thirdPartyAppAccessFlag = jsonUtils.JsonToOptionalBool(accessJson, THIRD_PARTY_APP_ACCESS_FLAG); + abilityAccess.serviceAccessFlag = jsonUtils.JsonToOptionalBool(accessJson, SERVICE_ACCESS_FLAG); + abilityAccess.defaultAccessFlag = jsonUtils.JsonToOptionalBool(accessJson, DEFAULT_ACCESS_FLAG); + LoadExtensionAllowOrBlockedList(accessJson, ALLOW_LIST, abilityAccess.allowList); + LoadExtensionAllowOrBlockedList(accessJson, BLOCK_LIST, abilityAccess.blockList); + + TAG_LOGD(AAFwkTag::ABILITYMGR, "The %{public}s extension's ability flag, third:%{public}s, service:%{public}s, " + "default:%{public}s, allowList size:%{public}zu, blockList size:%{public}zu,", extensionTypeName.c_str(), + FormatAccessFlag(abilityAccess.thirdPartyAppAccessFlag).c_str(), + FormatAccessFlag(abilityAccess.serviceAccessFlag).c_str(), + FormatAccessFlag(abilityAccess.defaultAccessFlag).c_str(), + abilityAccess.allowList.size(), abilityAccess.blockList.size()); + return true; +} + +std::string ExtensionConfig::FormatAccessFlag(const std::optional &flag) +{ + if (!flag.has_value()) { + return "null"; + } + return flag.value() ? "true" : "false"; +} + +void ExtensionConfig::LoadExtensionAllowOrBlockedList(const nlohmann::json &object, const std::string &key, + std::unordered_set &list) +{ + TAG_LOGD(AAFwkTag::ABILITYMGR, "LoadExtensionAllowOrBlockedList."); + if (!object.contains(key) || !object.at(key).is_array()) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s config null", key.c_str()); + return; + } + list.clear(); + for (auto &item : object.at(key).items()) { + const nlohmann::json& jsonObject = item.value(); + if (!jsonObject.is_string()) { + continue; + } + std::string serviceUri = jsonObject.get(); + if (CheckExtensionUriValid(serviceUri)) { + list.emplace(serviceUri); + } + } +} + void ExtensionConfig::LoadExtensionNetworkEnable(const nlohmann::json &object, const std::string &extensionTypeName) { TAG_LOGD(AAFwkTag::ABILITYMGR, "LoadExtensionNetworkEnable call"); - if (!object.contains(EXTENSION_NETWORK_ENABLE_FLAG) || !object.at(EXTENSION_NETWORK_ENABLE_FLAG).is_boolean()) { + if (!object.contains(NETWORK_ACCESS_ENABLE_FLAG) || !object.at(NETWORK_ACCESS_ENABLE_FLAG).is_boolean()) { TAG_LOGW(AAFwkTag::ABILITYMGR, "network enable flag null"); return; } - bool flag = object.at(EXTENSION_NETWORK_ENABLE_FLAG).get(); + bool flag = object.at(NETWORK_ACCESS_ENABLE_FLAG).get(); configMap_[extensionTypeName].networkEnableFlag = flag; TAG_LOGD(AAFwkTag::ABILITYMGR, "The %{public}s extension's network enable flag is %{public}d", extensionTypeName.c_str(), flag); @@ -201,16 +272,124 @@ void ExtensionConfig::LoadExtensionSAEnable(const nlohmann::json &object, const std::string &extensionTypeName) { TAG_LOGD(AAFwkTag::ABILITYMGR, "LoadExtensionSAEnable call"); - if (!object.contains(EXTENSION_SA_ENABLE_FLAG) || !object.at(EXTENSION_SA_ENABLE_FLAG).is_boolean()) { + if (!object.contains(SA_ACCESS_ENABLE_FLAG) || !object.at(SA_ACCESS_ENABLE_FLAG).is_boolean()) { TAG_LOGW(AAFwkTag::ABILITYMGR, "sa enable flag null"); return; } - bool flag = object.at(EXTENSION_SA_ENABLE_FLAG).get(); + bool flag = object.at(SA_ACCESS_ENABLE_FLAG).get(); configMap_[extensionTypeName].saEnableFlag = flag; TAG_LOGD(AAFwkTag::ABILITYMGR, "The %{public}s extension's sa enable flag is %{public}d", extensionTypeName.c_str(), flag); } +bool ExtensionConfig::HasAbilityAccess(const std::string &extensionTypeName) +{ + std::lock_guard lock(configMapMutex_); + auto iter = configMap_.find(extensionTypeName); + if (iter == configMap_.end()) { + return false; + } + return iter->second.hasAbilityAccess; +} + +bool ExtensionConfig::HasThridPartyAppAccessFlag(const std::string &extensionTypeName) +{ + auto accessFlag = GetSingleAccessFlag(extensionTypeName, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.thirdPartyAppAccessFlag; + }); + return accessFlag.has_value(); +} + +bool ExtensionConfig::HasServiceAccessFlag(const std::string &extensionTypeName) +{ + auto accessFlag = GetSingleAccessFlag(extensionTypeName, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.serviceAccessFlag; + }); + return accessFlag.has_value(); +} + +bool ExtensionConfig::HasDefaultAccessFlag(const std::string &extensionTypeName) +{ + auto accessFlag = GetSingleAccessFlag(extensionTypeName, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.defaultAccessFlag; + }); + return accessFlag.has_value(); +} + +std::optional ExtensionConfig::GetSingleAccessFlag(const std::string &extensionTypeName, + std::function(const AbilityAccessItem&)> getAccessFlag) +{ + std::lock_guard lock(configMapMutex_); + auto iter = configMap_.find(extensionTypeName); + if (iter == configMap_.end()) { + return std::nullopt; + } + return getAccessFlag(iter->second.abilityAccess); +} + +bool ExtensionConfig::IsExtensionStartThirdPartyAppEnableNew(const std::string &extensionTypeName, + const std::string &targetUri) +{ + return IsExtensionAbilityAccessEnable(extensionTypeName, targetUri, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.thirdPartyAppAccessFlag; + }); +} + +bool ExtensionConfig::IsExtensionStartServiceEnableNew(const std::string &extensionTypeName, + const std::string &targetUri) +{ + return IsExtensionAbilityAccessEnable(extensionTypeName, targetUri, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.serviceAccessFlag; + }); +} + +bool ExtensionConfig::IsExtensionStartDefaultEnable(const std::string &extensionTypeName, const std::string &targetUri) +{ + return IsExtensionAbilityAccessEnable(extensionTypeName, targetUri, [](const AbilityAccessItem &abilityAccess) { + return abilityAccess.defaultAccessFlag; + }); +} + +bool ExtensionConfig::IsExtensionAbilityAccessEnable(const std::string &extensionTypeName, const std::string &targetUri, + std::function(const AbilityAccessItem&)> getAccessFlag) +{ + AbilityAccessItem abilityAccess; + { + std::lock_guard lock(configMapMutex_); + auto iter = configMap_.find(extensionTypeName); + if (iter == configMap_.end()) { + return true; + } + abilityAccess = iter->second.abilityAccess; + } + auto accessFlag = getAccessFlag(abilityAccess); + if (!accessFlag.has_value()) { + // flag not configured, allow access + return true; + } + AppExecFwk::ElementName targetElementName; + if (!targetElementName.ParseURI(targetUri)) { + return accessFlag.value(); + } + if (accessFlag.value()) { + //flag true, deny access in block list + return !FindTargetUriInList(targetElementName, abilityAccess.blockList); + } + // flag false, allow access in allow list + return FindTargetUriInList(targetElementName, abilityAccess.allowList); +} + +bool ExtensionConfig::FindTargetUriInList(const AppExecFwk::ElementName &targetElementName, + std::unordered_set &list) +{ + return std::find_if(list.begin(), list.end(), [&](const auto &uri) { + AppExecFwk::ElementName iterElementName; + return iterElementName.ParseURI(uri) && + iterElementName.GetBundleName() == targetElementName.GetBundleName() && + iterElementName.GetAbilityName() == targetElementName.GetAbilityName(); + }) != list.end(); +} + bool ExtensionConfig::IsExtensionNetworkEnable(const std::string &extensionTypeName) { std::lock_guard lock(configMapMutex_); @@ -265,7 +444,7 @@ bool ExtensionConfig::ReadFileInfoJson(const std::string &filePath, nlohmann::js return true; } -bool ExtensionConfig::CheckServiceExtensionUriValid(const std::string &uri) +bool ExtensionConfig::CheckExtensionUriValid(const std::string &uri) { const size_t memberNum = 4; if (std::count(uri.begin(), uri.end(), '/') != memberNum - 1) { diff --git a/services/abilitymgr/src/interceptor/extension_control_interceptor.cpp b/services/abilitymgr/src/interceptor/extension_control_interceptor.cpp index ed72313eb1..2db9613c29 100644 --- a/services/abilitymgr/src/interceptor/extension_control_interceptor.cpp +++ b/services/abilitymgr/src/interceptor/extension_control_interceptor.cpp @@ -44,6 +44,15 @@ ErrCode ExtensionControlInterceptor::DoProcess(AbilityInterceptorParam param) return ERR_OK; } + if (!DelayedSingleton::GetInstance()->HasAbilityAccess(callerAbilityInfo.extensionTypeName)) { + return ProcessInterceptOld(param, targetAbilityInfo, callerAbilityInfo); + } + return ProcessInterceptNew(param, targetAbilityInfo, callerAbilityInfo); +} + +int32_t ExtensionControlInterceptor::ProcessInterceptOld(const AbilityInterceptorParam& param, + const AppExecFwk::AbilityInfo &targetAbilityInfo, const AppExecFwk::AbilityInfo &callerAbilityInfo) +{ // check blocked list if (!targetAbilityInfo.applicationInfo.isSystemApp && !DelayedSingleton::GetInstance()->IsExtensionStartThirdPartyAppEnable( @@ -53,7 +62,7 @@ ErrCode ExtensionControlInterceptor::DoProcess(AbilityInterceptorParam param) return EXTENSION_BLOCKED_BY_THIRD_PARTY_APP_FLAG; } if ((targetAbilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::SERVICE || - targetAbilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::DATASHARE) && + targetAbilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::DATASHARE) && !DelayedSingleton::GetInstance()->IsExtensionStartServiceEnable( callerAbilityInfo.extensionTypeName, param.want.GetElement().GetURI())) { TAG_LOGE(AAFwkTag::ABILITYMGR, "service list block extension call, bundleName: %{public}s", @@ -65,6 +74,50 @@ ErrCode ExtensionControlInterceptor::DoProcess(AbilityInterceptorParam param) return ERR_OK; } +int32_t ExtensionControlInterceptor::ProcessInterceptNew(const AbilityInterceptorParam& param, + const AppExecFwk::AbilityInfo &targetAbilityInfo, const AppExecFwk::AbilityInfo &callerAbilityInfo) +{ + auto extensionConfig = DelayedSingleton::GetInstance(); + if (!extensionConfig) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "extensionConfig null"); + return ERR_OK; + } + + auto targetUri = param.want.GetElement().GetURI(); + if (!targetAbilityInfo.applicationInfo.isSystemApp && + extensionConfig->HasThridPartyAppAccessFlag(callerAbilityInfo.extensionTypeName)) { + if (!extensionConfig->IsExtensionStartThirdPartyAppEnableNew(callerAbilityInfo.extensionTypeName, targetUri)) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "start third party app controlled by extension, bundleName: %{public}s", + callerAbilityInfo.bundleName.c_str()); + return EXTENSION_BLOCKED_BY_THIRD_PARTY_APP_FLAG; + } + return ERR_OK; + } + + auto isServiceOrDataShare = targetAbilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::SERVICE || + targetAbilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::DATASHARE; + if (isServiceOrDataShare && extensionConfig->HasServiceAccessFlag(callerAbilityInfo.extensionTypeName)) { + if (!extensionConfig->IsExtensionStartServiceEnableNew(callerAbilityInfo.extensionTypeName, targetUri)) { + TAG_LOGE(AAFwkTag::ABILITYMGR, + "start service or datashare controlled by extension, bundleName: %{public}s", + callerAbilityInfo.bundleName.c_str()); + return EXTENSION_BLOCKED_BY_SERVICE_LIST; + } + return ERR_OK; + } + + if (extensionConfig->HasDefaultAccessFlag(callerAbilityInfo.extensionTypeName)) { + if (!extensionConfig->IsExtensionStartDefaultEnable(callerAbilityInfo.extensionTypeName, targetUri)) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "start ability controlled by extension, bundleName: %{public}s", + callerAbilityInfo.bundleName.c_str()); + return ERR_EXTENSION_START_ABILITY_CONTROLEED; + } + return ERR_OK; + } + + return ERR_OK; +} + bool ExtensionControlInterceptor::GetCallerAbilityInfo(const AbilityInterceptorParam& param, AppExecFwk::AbilityInfo& callerAbilityInfo) { diff --git a/services/common/include/json_utils.h b/services/common/include/json_utils.h index 8eed8db121..66dc39898d 100644 --- a/services/common/include/json_utils.h +++ b/services/common/include/json_utils.h @@ -18,6 +18,7 @@ #include #include +#include #include "nlohmann/json.hpp" #include "singleton.h" @@ -79,6 +80,15 @@ public: */ bool IsEqual(nlohmann::json &jsonObject, const std::string &key, int32_t value); + /** + * parse json to optional bool. + * + * @param jsonObject The json object. + * @param key The key. + * @return optional boolean value. + */ + std::optional JsonToOptionalBool(const nlohmann::json &jsonObject, const std::string &key); + private: std::string GetConfigPath(const std::string& path, const std::string& defaultPath); bool ReadFileInfoJson(const std::string &filePath, nlohmann::json &jsonBuf); diff --git a/services/common/src/json_utils.cpp b/services/common/src/json_utils.cpp index c9f79fd66e..ba5c58594b 100644 --- a/services/common/src/json_utils.cpp +++ b/services/common/src/json_utils.cpp @@ -114,5 +114,13 @@ bool JsonUtils::IsEqual(nlohmann::json &jsonObject, const std::string &key, int3 } return true; } + +std::optional JsonUtils::JsonToOptionalBool(const nlohmann::json &jsonObject, const std::string &key) +{ + if (jsonObject.contains(key) && jsonObject[key].is_boolean()) { + return jsonObject[key].get(); + } + return std::nullopt; +} } // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/test/fuzztest/extensionconfig_fuzzer/BUILD.gn b/test/fuzztest/extensionconfig_fuzzer/BUILD.gn index 62f63878ce..fb17775e88 100644 --- a/test/fuzztest/extensionconfig_fuzzer/BUILD.gn +++ b/test/fuzztest/extensionconfig_fuzzer/BUILD.gn @@ -51,6 +51,7 @@ ohos_fuzztest("ExtensionConfigFuzzTest") { "${ability_runtime_native_path}/ability/native:abilitykit_native", "${ability_runtime_services_path}/abilitymgr:abilityms", "${ability_runtime_services_path}/abilitymgr:ams_configuration_parameter", + "${ability_runtime_services_path}/common:app_util", ] external_deps = [ diff --git a/test/fuzztest/extensionconfig_fuzzer/extensionconfig_fuzzer.cpp b/test/fuzztest/extensionconfig_fuzzer/extensionconfig_fuzzer.cpp index 066eb3c9ca..baeff74603 100644 --- a/test/fuzztest/extensionconfig_fuzzer/extensionconfig_fuzzer.cpp +++ b/test/fuzztest/extensionconfig_fuzzer/extensionconfig_fuzzer.cpp @@ -54,6 +54,13 @@ bool DoSomethingInterestingWithMyAPI(const char *data, size_t size) extensionConfig->GetExtensionAutoDisconnectTime(strParam); extensionConfig->IsExtensionStartThirdPartyAppEnable(strParam); extensionConfig->IsExtensionStartServiceEnable(strParam, strParam); + extensionConfig->HasAbilityAccess(strParam); + extensionConfig->HasThridPartyAppAccessFlag(strParam); + extensionConfig->HasServiceAccessFlag(strParam); + extensionConfig->HasDefaultAccessFlag(strParam); + extensionConfig->IsExtensionStartServiceEnableNew(strParam, strParam); + extensionConfig->IsExtensionStartThirdPartyAppEnableNew(strParam, strParam); + extensionConfig->IsExtensionStartDefaultEnable(strParam, strParam); nlohmann::json object; extensionConfig->LoadExtensionConfig(object); extensionConfig->ReadFileInfoJson(strParam, object); @@ -61,7 +68,8 @@ bool DoSomethingInterestingWithMyAPI(const char *data, size_t size) extensionConfig->LoadExtensionAutoDisconnectTime(object, strParam); extensionConfig->LoadExtensionThirdPartyAppBlockedList(object, strParam); extensionConfig->LoadExtensionServiceBlockedList(object, strParam); - extensionConfig->CheckServiceExtensionUriValid(strParam); + extensionConfig->LoadExtensionAbilityAccess(object, strParam); + extensionConfig->CheckExtensionUriValid(strParam); return true; } } // namespace OHOS diff --git a/test/unittest/ability_extension_config_test/BUILD.gn b/test/unittest/ability_extension_config_test/BUILD.gn index a5df73cbf0..e6f57b6337 100644 --- a/test/unittest/ability_extension_config_test/BUILD.gn +++ b/test/unittest/ability_extension_config_test/BUILD.gn @@ -32,6 +32,7 @@ ohos_unittest("ability_extension_config_test") { deps = [ "${ability_runtime_innerkits_path}/ability_manager:ability_manager", "${ability_runtime_services_path}/abilitymgr:abilityms", + "${ability_runtime_services_path}/common:app_util", ] external_deps = [ diff --git a/test/unittest/ability_extension_config_test/ability_extension_config_test.cpp b/test/unittest/ability_extension_config_test/ability_extension_config_test.cpp index 2c81697646..51c1ff0471 100644 --- a/test/unittest/ability_extension_config_test/ability_extension_config_test.cpp +++ b/test/unittest/ability_extension_config_test/ability_extension_config_test.cpp @@ -19,11 +19,12 @@ #include "extension_config.h" #undef private #undef protected +#include "hilog_tag_wrapper.h" +#include "json_utils.h" using namespace testing; using namespace testing::ext; using json = nlohmann::json; - namespace { constexpr const char* EXTENSION_CONFIG_NAME = "extension_config_name"; constexpr const char* EXTENSION_TYPE_NAME = "extension_type_name"; @@ -32,8 +33,6 @@ constexpr const char* EXTENSION_AUTO_DISCONNECT_TIME = "auto_disconnect_time"; constexpr const char* EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME = "third_party_app_blocked_flag"; constexpr const char* EXTENSION_SERVICE_BLOCKED_LIST_NAME = "service_blocked_list"; constexpr const char* EXTENSION_SERVICE_STARTUP_ENABLE_FLAG = "service_startup_enable_flag"; -constexpr const char* EXTENSION_NETWORK_ENABLE_FLAG = "network_access_enable_flag"; -constexpr const char* EXTENSION_SA_ENABLE_FLAG = "sa_access_enable_flag"; } namespace OHOS { namespace AbilityRuntime { @@ -44,6 +43,7 @@ public: void SetUp() override; void TearDown() override; public: + void LoadTestConfig(const std::string &configStr); static std::shared_ptr extensionConfig_; }; @@ -57,11 +57,19 @@ void AbilityExtensionConfigTest::TearDownTestCase(void) {} void AbilityExtensionConfigTest::SetUp() -{} +{ + extensionConfig_->configMap_.clear(); +} void AbilityExtensionConfigTest::TearDown() {} +void AbilityExtensionConfigTest::LoadTestConfig(const std::string &configStr) +{ + nlohmann::json jsonConfig = nlohmann::json::parse(configStr); + extensionConfig_->LoadExtensionConfig(jsonConfig); +} + /* * @tc.number : GetExtensionConfigPath_001 * @tc.name : AbilityExtensionConfigTest @@ -145,30 +153,6 @@ HWTEST_F(AbilityExtensionConfigTest, LoadExtensionConfig_001, TestSize.Level1) EXPECT_TRUE(extensionConfig_ != nullptr); } -/* - * @tc.number : CheckServiceExtensionUriValid_001 - * @tc.name : AbilityExtensionConfigTest - * @tc.desc : Test Function CheckServiceExtensionUriValid - */ -HWTEST_F(AbilityExtensionConfigTest, CheckServiceExtensionUriValid_001, TestSize.Level1) -{ - auto result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa/bb/"); - EXPECT_EQ(result, false); - result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa/bb/cc/"); - EXPECT_EQ(result, false); - result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa//cc/"); - EXPECT_EQ(result, false); - result = extensionConfig_->CheckServiceExtensionUriValid("/bundleName/moduleName/abilityName"); - EXPECT_EQ(result, true); - result = extensionConfig_->CheckServiceExtensionUriValid("deviceName/bundleName/moduleName/abilityName"); - EXPECT_EQ(result, true); - AppExecFwk::ElementName targetElementName; - EXPECT_EQ(targetElementName.ParseURI("deviceName/bundleName/moduleName/abilityName"), true); - EXPECT_EQ(targetElementName.GetBundleName(), "bundleName"); - EXPECT_EQ(targetElementName.GetModuleName(), "moduleName"); - EXPECT_EQ(targetElementName.GetAbilityName(), "abilityName"); -} - /* * @tc.number : IsExtensionStartServiceEnable_001 * @tc.name : AbilityExtensionConfigTest @@ -246,34 +230,964 @@ HWTEST_F(AbilityExtensionConfigTest, ReadFileInfoJson_001, TestSize.Level1) } /* - * @tc.number : LoadExtensionNetworkEnable_001 + * @tc.number : CheckExtensionUriValid_001 * @tc.name : AbilityExtensionConfigTest - * @tc.desc : Test Function LoadExtensionNetworkEnable + * @tc.desc : Test Function CheckExtensionUriValid */ -HWTEST_F(AbilityExtensionConfigTest, LoadExtensionNetworkEnable_001, TestSize.Level1) +HWTEST_F(AbilityExtensionConfigTest, CheckExtensionUriValid_001, TestSize.Level1) { - json jsOnFile; - jsOnFile[EXTENSION_NETWORK_ENABLE_FLAG] = false; - ASSERT_NE(extensionConfig_, nullptr); - extensionConfig_->configMap_.clear(); - extensionConfig_->LoadExtensionNetworkEnable(jsOnFile, "form"); - EXPECT_FALSE(extensionConfig_->configMap_["form"].networkEnableFlag); + auto result = extensionConfig_->CheckExtensionUriValid("http://aaa/bb/"); + EXPECT_EQ(result, false); + result = extensionConfig_->CheckExtensionUriValid("http://aaa/bb/cc/"); + EXPECT_EQ(result, false); + result = extensionConfig_->CheckExtensionUriValid("http://aaa//cc/"); + EXPECT_EQ(result, false); + result = extensionConfig_->CheckExtensionUriValid("/bundleName/moduleName/abilityName"); + EXPECT_EQ(result, true); + result = extensionConfig_->CheckExtensionUriValid("deviceName/bundleName/moduleName/abilityName"); + EXPECT_EQ(result, true); + AppExecFwk::ElementName targetElementName; + EXPECT_EQ(targetElementName.ParseURI("deviceName/bundleName/moduleName/abilityName"), true); + EXPECT_EQ(targetElementName.GetBundleName(), "bundleName"); + EXPECT_EQ(targetElementName.GetModuleName(), "moduleName"); + EXPECT_EQ(targetElementName.GetAbilityName(), "abilityName"); } /* - * @tc.number : LoadExtensionSAEnable_001 + * @tc.number : GetExtensionAutoDisconnectTime_001 * @tc.name : AbilityExtensionConfigTest - * @tc.desc : Test Function LoadExtensionSAEnable + * @tc.desc : Test Function GetExtensionAutoDisconnectTime */ -HWTEST_F(AbilityExtensionConfigTest, LoadExtensionSAEnable_001, TestSize.Level1) +HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_001, TestSize.Level1) { - json jsOnFile; - jsOnFile[EXTENSION_SA_ENABLE_FLAG] = false; - auto extType = "form"; + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "auto_disconnect_time": 5000 + }] + })"; + LoadTestConfig(configStr); + auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form"); + EXPECT_EQ(disconnectTime, 5000); + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_001 end."); +} + +/* + * @tc.number : GetExtensionAutoDisconnectTime_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function GetExtensionAutoDisconnectTime + */ +HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form" + }] + })"; + LoadTestConfig(configStr); + auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form"); + EXPECT_EQ(disconnectTime, -1); + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_002 end."); +} + +/* + * @tc.number : GetExtensionAutoDisconnectTime_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function GetExtensionAutoDisconnectTime + */ +HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "auto_disconnect_time": "invalid_value" + }] + })"; + LoadTestConfig(configStr); + auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form"); + EXPECT_EQ(disconnectTime, -1); + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_003 end."); +} + +/* + * @tc.number : GetExtensionAutoDisconnectTime_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function GetExtensionAutoDisconnectTime + */ +HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": 2, + "auto_disconnect_time": "invalid_value" + }] + })"; + LoadTestConfig(configStr); + auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form"); + EXPECT_EQ(disconnectTime, -1); + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_004 end."); +} + +/* + * @tc.number : GetExtensionAutoDisconnectTime_005 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function GetExtensionAutoDisconnectTime + */ +HWTEST_F(AbilityExtensionConfigTest, GetExtensionAutoDisconnectTime_005, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_005 start."); + const std::string configStr = R"({ + "ams_extension_config": [] + })"; + LoadTestConfig(configStr); + auto disconnectTime = extensionConfig_->GetExtensionAutoDisconnectTime("form"); + EXPECT_EQ(disconnectTime, -1); + TAG_LOGI(AAFwkTag::TEST, "GetExtensionAutoDisconnectTime_005 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form" + }] + })"; ASSERT_NE(extensionConfig_, nullptr); - extensionConfig_->configMap_.clear(); - extensionConfig_->LoadExtensionSAEnable(jsOnFile, extType); - EXPECT_FALSE(extensionConfig_->configMap_[extType].saEnableFlag); + LoadTestConfig(configStr); + auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag; + EXPECT_EQ(flag, std::nullopt); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_001 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : 1 + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag; + EXPECT_EQ(flag, std::nullopt); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_002 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : {} + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + auto flag = extensionConfig_->configMap_["form"].abilityAccess.thirdPartyAppAccessFlag; + EXPECT_EQ(flag, std::nullopt); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_003 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": "invalid_value", + "allowlist" : "invalid_value" + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess; + auto flag = abilityAccess.thirdPartyAppAccessFlag; + EXPECT_EQ(flag, std::nullopt); + auto allowListSize = abilityAccess.allowList.size(); + EXPECT_EQ(allowListSize, 0); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_004 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_005 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_005, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_005 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "allowlist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess; + auto allowListSize = abilityAccess.allowList.size(); + EXPECT_EQ(allowListSize, 0); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_005 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_006 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_006, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_006 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "allowlist" : [123] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess; + auto allowListSize = abilityAccess.allowList.size(); + EXPECT_EQ(allowListSize, 0); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_006 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_007 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_007, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_007 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "allowlist" : [123] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess; + auto allowListSize = abilityAccess.allowList.size(); + EXPECT_EQ(allowListSize, 0); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_007 end."); +} + +/* + * @tc.number : LoadExtensionAbilityAccess_008 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function LoadExtensionAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAbilityAccess_008, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_008 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "allowlist" : ["invalidUrl"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + auto &abilityAccess = extensionConfig_->configMap_["form"].abilityAccess; + auto allowListSize = abilityAccess.allowList.size(); + EXPECT_EQ(allowListSize, 0); + TAG_LOGI(AAFwkTag::TEST, "LoadExtensionAbilityAccess_008 end."); +} + +/* + * @tc.number : HasAbilityAccess_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, HasAbilityAccess_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasAbilityAccess("form"); + EXPECT_FALSE(result); + TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_001 end."); +} + +/* + * @tc.number : HasAbilityAccess_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasAbilityAccess + */ +HWTEST_F(AbilityExtensionConfigTest, HasAbilityAccess_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access": { + "third_party_app_access_flag": false + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasAbilityAccess("form"); + EXPECT_TRUE(result); + TAG_LOGI(AAFwkTag::TEST, "HasAbilityAccess_002 end."); +} + +/* + * @tc.number : HasThridPartyAppAccessFlag_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasThridPartyAppAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasThridPartyAppAccessFlag("form"); + EXPECT_FALSE(result); + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_001 end."); +} + +/* + * @tc.number : HasThridPartyAppAccessFlag_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasThridPartyAppAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_002 start."); + + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form" + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasThridPartyAppAccessFlag("form"); + EXPECT_FALSE(result); + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_002 end."); +} + +/* + * @tc.number : HasThridPartyAppAccessFlag_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasThridPartyAppAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : {} + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasThridPartyAppAccessFlag("form"); + EXPECT_FALSE(result); + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_003 end."); +} + +/* + * @tc.number : HasThridPartyAppAccessFlag_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasThridPartyAppAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasThridPartyAppAccessFlag_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": false + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasThridPartyAppAccessFlag("form"); + EXPECT_TRUE(result); + TAG_LOGI(AAFwkTag::TEST, "HasThridPartyAppAccessFlag_004 end."); +} + +/* + * @tc.number : HasServiceAccessFlag_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasServiceAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasServiceAccessFlag_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasServiceAccessFlag_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "service_access_flag": false + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasServiceAccessFlag("form"); + EXPECT_TRUE(result); + TAG_LOGI(AAFwkTag::TEST, "HasServiceAccessFlag_001 end."); +} + +/* + * @tc.number : HasDefaultAccessFlag_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function HasDefaultAccessFlag + */ +HWTEST_F(AbilityExtensionConfigTest, HasDefaultAccessFlag_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "HasDefaultAccessFlag_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "default_access_flag": false + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool result = extensionConfig_->HasDefaultAccessFlag("form"); + EXPECT_TRUE(result); + TAG_LOGI(AAFwkTag::TEST, "HasDefaultAccessFlag_001 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_001 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : {} + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_002 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": false + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", "invalid_uri"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_003 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": true + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", "invalid_uri"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_004 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_005 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_005, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_005 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": true, + "blocklist" : ["/com.acts.helloworld2/entry/BlockAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_005 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_006 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_006, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_006 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": true, + "blocklist" : ["/com.acts.helloworld/entry/BlockAbility2"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_006 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_007 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_007, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_007 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": true, + "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_007 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_008 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_008, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_008 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": true, + "blocklist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_008 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_009 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_009, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_009 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": false, + "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_009 end."); +} + +/* + * @tc.number : IsExtensionStartThirdPartyAppEnableNew_010 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartThirdPartyAppEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartThirdPartyAppEnableNew_010, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_010 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "third_party_app_access_flag": false, + "allowlist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartThirdPartyAppEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartThirdPartyAppEnableNew_010 end."); +} + +/* + * @tc.number : IsExtensionStartServiceEnableNew_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartServiceEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "service_access_flag": true, + "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_001 end."); +} + +/* + * @tc.number : IsExtensionStartServiceEnableNew_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartServiceEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "service_access_flag": true, + "blocklist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_002 end."); +} + +/* + * @tc.number : IsExtensionStartServiceEnableNew_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartServiceEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "service_access_flag": false, + "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_003 end."); +} + +/* + * @tc.number : IsExtensionStartServiceEnableNew_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartServiceEnableNew + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnableNew_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "service_access_flag": false, + "allowlist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartServiceEnableNew("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartServiceEnableNew_004 end."); +} + +/* + * @tc.number : IsExtensionStartDefaultEnable_001 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartDefaultEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "default_access_flag": true, + "blocklist" : ["/com.acts.helloworld/entry/BlockAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_001 end."); +} + +/* + * @tc.number : IsExtensionStartDefaultEnable_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartDefaultEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "default_access_flag": true, + "blocklist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form", + "/com.acts.helloworld/entry/BlockAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_002 end."); +} + +/* + * @tc.number : IsExtensionStartDefaultEnable_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartDefaultEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "default_access_flag": false, + "allowlist" : ["/com.acts.helloworld/entry/AllowAbility1"] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_003 end."); +} + +/* + * @tc.number : IsExtensionStartDefaultEnable_004 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionStartDefaultEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartDefaultEnable_004, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_004 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "ability_access" : { + "default_access_flag": false, + "allowlist" : [] + } + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionStartDefaultEnable("form", + "/com.acts.helloworld/entry/AllowAbility1"); + EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionStartDefaultEnable_004 end."); } /* @@ -283,12 +1197,63 @@ HWTEST_F(AbilityExtensionConfigTest, LoadExtensionSAEnable_001, TestSize.Level1) */ HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_001, TestSize.Level1) { - auto extType = "form"; + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "network_access_enable_flag": true + }] + })"; ASSERT_NE(extensionConfig_, nullptr); - extensionConfig_->configMap_.clear(); - extensionConfig_->configMap_[extType].networkEnableFlag = false; - bool enable = extensionConfig_->IsExtensionNetworkEnable(extType); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionNetworkEnable("form"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 end."); +} + +/* + * @tc.number : IsExtensionNetworkEnable_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionNetworkEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "network_access_enable_flag": "invalid_value" + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionNetworkEnable("form"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_001 end."); +} + +/* + * @tc.number : IsExtensionNetworkEnable_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionNetworkEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "network_access_enable_flag": false + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionNetworkEnable("form"); EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionNetworkEnable_003 end."); } /* @@ -298,12 +1263,63 @@ HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_001, TestSize.Leve */ HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_001, TestSize.Level1) { - auto extType = "form"; + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_001 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "sa_access_enable_flag": true + }] + })"; ASSERT_NE(extensionConfig_, nullptr); - extensionConfig_->configMap_.clear(); - extensionConfig_->configMap_[extType].saEnableFlag = false; - bool enable = extensionConfig_->IsExtensionSAEnable(extType); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionSAEnable("form"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_001 end."); +} + +/* + * @tc.number : IsExtensionSAEnable_002 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionSAEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_002, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_002 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "sa_access_enable_flag": "invalid_value" + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionSAEnable("form"); + EXPECT_TRUE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_002 end."); +} + +/* + * @tc.number : IsExtensionSAEnable_003 + * @tc.name : AbilityExtensionConfigTest + * @tc.desc : Test Function IsExtensionSAEnable + */ +HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_003, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_003 start."); + const std::string configStr = R"({ + "ams_extension_config": [{ + "name": "FormExtension", + "extension_type_name": "form", + "sa_access_enable_flag": false + }] + })"; + ASSERT_NE(extensionConfig_, nullptr); + LoadTestConfig(configStr); + bool enable = extensionConfig_->IsExtensionSAEnable("form"); EXPECT_FALSE(enable); + TAG_LOGI(AAFwkTag::TEST, "IsExtensionSAEnable_003 end."); } } }