From 0020b18d18f6be11477c161027d839611b6bb762 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Thu, 14 Aug 2025 16:38:23 +0800 Subject: [PATCH 01/76] fix appid Signed-off-by: wenjinchao Change-Id: I82edea6f91370270b4af5c88fb45d3b0e8d86d26 --- .../adapter/bundle_mgr/BUILD.gn | 45 --------- .../adapter/bundle_mgr/bundlemgr_adapter.cpp | 96 ------------------- .../include/bundle_mgr/bundlemgr_adapter.h | 39 -------- .../app/src/checker/BUILD.gn | 5 +- .../app/src/checker/bundle_checker.cpp | 53 +++++++++- .../app/src/checker/bundle_checker.h | 7 ++ .../app/src/kvstore_data_service.cpp | 11 +-- .../framework/checker/checker_manager.cpp | 20 ++++ .../include/checker/checker_manager.h | 4 + .../framework/test/BUILD.gn | 1 - .../distributeddataservice/service/BUILD.gn | 1 - .../test/fuzztest/udmfservice_fuzzer/BUILD.gn | 1 - .../service/udmf/BUILD.gn | 1 - .../udmf/preprocess/preprocess_utils.cpp | 5 +- .../service/udmf/udmf_service_impl.cpp | 5 +- 15 files changed, 92 insertions(+), 202 deletions(-) delete mode 100644 services/distributeddataservice/adapter/bundle_mgr/BUILD.gn delete mode 100644 services/distributeddataservice/adapter/bundle_mgr/bundlemgr_adapter.cpp delete mode 100644 services/distributeddataservice/adapter/include/bundle_mgr/bundlemgr_adapter.h diff --git a/services/distributeddataservice/adapter/bundle_mgr/BUILD.gn b/services/distributeddataservice/adapter/bundle_mgr/BUILD.gn deleted file mode 100644 index 93bb21bc3..000000000 --- a/services/distributeddataservice/adapter/bundle_mgr/BUILD.gn +++ /dev/null @@ -1,45 +0,0 @@ -# Copyright (c) 2025 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") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -ohos_source_set("distributedata_bundlemgr") { - branch_protector_ret = "pac_ret" - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false - boundary_sanitize = true - ubsan = true - } - sources = [ "bundlemgr_adapter.cpp" ] - - cflags_cc = [ "-fvisibility=hidden" ] - - if (build_public_version) { - cflags_cc += [ "-DCONFIG_PUBLIC_VERSION" ] - } - - include_dirs = [ "${data_service_path}/adapter/include/bundle_mgr" ] - ldflags = [ "-Wl,--exclude-libs,ALL" ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "bundle_framework:appexecfwk_core", - "hilog:libhilog", - "kv_store:datamgr_common", - ] - subsystem_name = "distributeddatamgr" - part_name = "datamgr_service" - defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] -} diff --git a/services/distributeddataservice/adapter/bundle_mgr/bundlemgr_adapter.cpp b/services/distributeddataservice/adapter/bundle_mgr/bundlemgr_adapter.cpp deleted file mode 100644 index fd17f5427..000000000 --- a/services/distributeddataservice/adapter/bundle_mgr/bundlemgr_adapter.cpp +++ /dev/null @@ -1,96 +0,0 @@ -/* -* Copyright (c) 2025 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. -*/ -#define LOG_TAG "BundleMgrAdapter" - -#include "bundlemgr_adapter.h" -#include -#include "accesstoken_kit.h" -#include "bundlemgr/bundle_mgr_proxy.h" -#include "ipc_skeleton.h" -#include "iservice_registry.h" -#include "log_print.h" -#include "system_ability_definition.h" - -namespace OHOS { -namespace DistributedData { -BundleMgrAdapter::BundleMgrAdapter() -{ -} -BundleMgrAdapter::~BundleMgrAdapter() -{ -} -BundleMgrAdapter& BundleMgrAdapter::GetInstance() -{ - static BundleMgrAdapter instance; - return instance; -} - -std::string BundleMgrAdapter::GetKey(const std::string &bundleName, int32_t userId) -{ - return bundleName + "###" + std::to_string(userId); -} - -std::string BundleMgrAdapter::GetAppidFromCache(const std::string &bundleName, int32_t userId) -{ - std::string appId; - std::string key = GetKey(bundleName, userId); - appIds_.Get(key, appId); - return appId; -} - -std::string BundleMgrAdapter::GetBundleAppId(const std::string &bundleName, int32_t userId) -{ - std::string appId = GetAppidFromCache(bundleName, userId); - if (!appId.empty()) { - return appId; - } - auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); - if (samgrProxy == nullptr) { - ZLOGE("Failed to get system ability mgr."); - return ""; - } - auto bundleMgrProxy = samgrProxy->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); - if (bundleMgrProxy == nullptr) { - ZLOGE("Failed to Get BMS SA."); - return ""; - } - auto bundleManager = iface_cast(bundleMgrProxy); - if (bundleManager == nullptr) { - ZLOGE("Failed to get bundle manager"); - return ""; - } - appId = bundleManager->GetAppIdByBundleName(bundleName, userId); - if (appId.empty()) { - ZLOGE("GetAppIdByBundleName failed appId:%{public}s, bundleName:%{public}s, uid:%{public}d", - appId.c_str(), bundleName.c_str(), userId); - } else { - appIds_.Set(GetKey(bundleName, userId), appId); - } - return appId; -} - -void BundleMgrAdapter::DeleteCache(const std::string &bundleName, int32_t user) -{ - std::string key = GetKey(bundleName, user); - appIds_.Delete(key); -} - -void BundleMgrAdapter::ClearCache() -{ - appIds_.ResetCapacity(0); - appIds_.ResetCapacity(CACHE_SIZE); -} -} // namespace DistributedData -} // namespace OHOS \ No newline at end of file diff --git a/services/distributeddataservice/adapter/include/bundle_mgr/bundlemgr_adapter.h b/services/distributeddataservice/adapter/include/bundle_mgr/bundlemgr_adapter.h deleted file mode 100644 index 5519c9b10..000000000 --- a/services/distributeddataservice/adapter/include/bundle_mgr/bundlemgr_adapter.h +++ /dev/null @@ -1,39 +0,0 @@ -/* -* Copyright (c) 2025 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. -*/ - -#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_BUNDLEMGR_ADAPTER_H -#define OHOS_DISTRIBUTED_DATA_SERVICES_BUNDLEMGR_ADAPTER_H -#include "lru_bucket.h" -#include "visibility.h" -namespace OHOS { -namespace DistributedData { -class BundleMgrAdapter { -public: - BundleMgrAdapter(); - ~BundleMgrAdapter(); - API_EXPORT static BundleMgrAdapter& GetInstance(); - API_EXPORT std::string GetBundleAppId(const std::string &bundleName, int32_t userId); - API_EXPORT void DeleteCache(const std::string &bundleName, int32_t user); - API_EXPORT void ClearCache(); - -private: - std::string GetAppidFromCache(const std::string &bundleName, int32_t userId); - std::string GetKey(const std::string &bundleName, int32_t userId); - static constexpr int32_t CACHE_SIZE = 32; - LRUBucket appIds_ {CACHE_SIZE}; -}; -} // namespace DistributedData -} // namespace OHOS -#endif // OHOS_DISTRIBUTED_DATA_SERVICES_BUNDLEMGR_ADAPTER_H \ No newline at end of file diff --git a/services/distributeddataservice/app/src/checker/BUILD.gn b/services/distributeddataservice/app/src/checker/BUILD.gn index 0ad405bb9..f0fa8dd25 100644 --- a/services/distributeddataservice/app/src/checker/BUILD.gn +++ b/services/distributeddataservice/app/src/checker/BUILD.gn @@ -32,10 +32,7 @@ ohos_source_set("distributeddata_checker") { "-Oz", ] - include_dirs = [ - "${data_service_path}/adapter/include", - "${data_service_path}/framework/include", - ] + include_dirs = [ "${data_service_path}/framework/include" ] if (build_public_version) { cflags_cc += [ "-DCONFIG_PUBLIC_VERSION" ] diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.cpp b/services/distributeddataservice/app/src/checker/bundle_checker.cpp index 1bfc0fd21..b726ab915 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.cpp +++ b/services/distributeddataservice/app/src/checker/bundle_checker.cpp @@ -18,7 +18,6 @@ #include #include "accesstoken_kit.h" #include "bundlemgr/bundle_mgr_proxy.h" -#include "bundle_mgr/bundlemgr_adapter.h" #include "hap_token_info.h" #include "ipc_skeleton.h" #include "iservice_registry.h" @@ -62,13 +61,63 @@ bool BundleChecker::SetSwitchesInfo(const CheckerManager::Switches &switches) return true; } +std::string BundleChecker::GetKey(const std::string &bundleName, int32_t userId) +{ + return bundleName + "###" + std::to_string(userId); +} + +std::string BundleChecker::GetAppidFromCache(const std::string &bundleName, int32_t userId) +{ + std::string appId; + std::string key = GetKey(bundleName, userId); + appIds_.Get(key, appId); + return appId; +} + std::string BundleChecker::GetBundleAppId(const CheckerManager::StoreInfo &info) { int32_t userId = info.uid / OHOS::AppExecFwk::Constants::BASE_USER_RANGE; - std::string appId = BundleMgrAdapter::GetInstance().GetBundleAppId(info.bundleName, userId); + std::string appId = GetAppidFromCache(info.bundleName, userId); + if (!appId.empty()) { + return appId; + } + auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgrProxy == nullptr) { + ZLOGE("Failed to get system ability mgr."); + return ""; + } + auto bundleMgrProxy = samgrProxy->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + if (bundleMgrProxy == nullptr) { + ZLOGE("Failed to Get BMS SA."); + return ""; + } + auto bundleManager = iface_cast(bundleMgrProxy); + if (bundleManager == nullptr) { + ZLOGE("Failed to get bundle manager"); + return ""; + } + appId = bundleManager->GetAppIdByBundleName(info.bundleName, userId); + if (appId.empty()) { + ZLOGE("GetAppIdByBundleName failed appId:%{public}s, bundleName:%{public}s, uid:%{public}d", + appId.c_str(), info.bundleName.c_str(), userId); + } else { + appIds_.Set(GetKey(info.bundleName, userId), appId); + } return appId; } +void BundleChecker::DeleteCache(const std::string &bundleName, int32_t user, int32_t index) +{ + std::string key = GetKey(bundleName, user); + appIds_.Delete(key); +} + +void BundleChecker::ClearCache() +{ + appIds_.ResetCapacity(0); + appIds_.ResetCapacity(CACHE_SIZE); +} + std::string BundleChecker::GetAppId(const CheckerManager::StoreInfo &info) { if (AccessTokenKit::GetTokenTypeFlag(info.tokenId) != TOKEN_HAP) { diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.h b/services/distributeddataservice/app/src/checker/bundle_checker.h index b0c63431a..a7b07159c 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.h +++ b/services/distributeddataservice/app/src/checker/bundle_checker.h @@ -16,6 +16,7 @@ #ifndef OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CHECKER_BUNDLE_CHECKER_H #define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CHECKER_BUNDLE_CHECKER_H #include "checker/checker_manager.h" +#include "lru_bucket.h" namespace OHOS { namespace DistributedData { class BundleChecker : public CheckerManager::Checker { @@ -36,7 +37,12 @@ public: std::vector GetStaticStores() override; bool IsDynamic(const CheckerManager::StoreInfo &info) override; bool IsStatic(const CheckerManager::StoreInfo &info) override; + void DeleteCache(const std::string &bundleName, int32_t user, int32_t index) override; + void ClearCache() override; private: + static constexpr int32_t CACHE_SIZE = 32; + std::string GetAppidFromCache(const std::string &bundleName, int32_t userId); + std::string GetKey(const std::string &bundleName, int32_t userId); static BundleChecker instance_; std::map trusts_; std::map distrusts_; @@ -44,6 +50,7 @@ private: std::vector dynamicStores_; std::vector staticStores_; std::string GetBundleAppId(const CheckerManager::StoreInfo &info); + LRUBucket appIds_ {CACHE_SIZE}; }; } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index 9d5058899..51af0c61e 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -29,7 +29,6 @@ #include "auth_delegate.h" #include "auto_launch_export.h" #include "bootstrap.h" -#include "bundle_mgr/bundlemgr_adapter.h" #include "checker/checker_manager.h" #include "communication_provider.h" #include "communicator_context.h" @@ -931,7 +930,7 @@ void KvStoreDataService::AccountEventChanged(const AccountEventInfo &eventInfo) MetaDataManager::GetInstance().DelMeta(StoreMetaMapping(meta).GetKey(), true); PermitDelegate::GetInstance().DelCache(meta.GetKeyWithoutPath()); } - BundleMgrAdapter::GetInstance().ClearCache(); + CheckerManager::GetInstance().ClearCache(); g_kvStoreAccountEventStatus = 0; break; } @@ -1051,7 +1050,7 @@ void KvStoreDataService::OnSessionReady(const AppDistributedKv::DeviceInfo &info int32_t KvStoreDataService::OnUninstall(const std::string &bundleName, int32_t user, int32_t index) { - BundleMgrAdapter::GetInstance().DeleteCache(bundleName, user); + CheckerManager::GetInstance().DeleteCache(bundleName, user, index); auto staticActs = FeatureSystem::GetInstance().GetStaticActs(); staticActs.ForEachCopies([bundleName, user, index](const auto &, const std::shared_ptr& acts) { acts->OnAppUninstall(bundleName, user, index); @@ -1062,7 +1061,7 @@ int32_t KvStoreDataService::OnUninstall(const std::string &bundleName, int32_t u int32_t KvStoreDataService::OnUpdate(const std::string &bundleName, int32_t user, int32_t index) { - BundleMgrAdapter::GetInstance().DeleteCache(bundleName, user); + CheckerManager::GetInstance().DeleteCache(bundleName, user, index); auto staticActs = FeatureSystem::GetInstance().GetStaticActs(); staticActs.ForEachCopies([bundleName, user, index](const auto &, const std::shared_ptr& acts) { acts->OnAppUpdate(bundleName, user, index); @@ -1073,7 +1072,7 @@ int32_t KvStoreDataService::OnUpdate(const std::string &bundleName, int32_t user int32_t KvStoreDataService::OnInstall(const std::string &bundleName, int32_t user, int32_t index) { - BundleMgrAdapter::GetInstance().DeleteCache(bundleName, user); + CheckerManager::GetInstance().DeleteCache(bundleName, user, index); auto staticActs = FeatureSystem::GetInstance().GetStaticActs(); staticActs.ForEachCopies([bundleName, user, index](const auto &, const std::shared_ptr& acts) { acts->OnAppInstall(bundleName, user, index); @@ -1094,7 +1093,7 @@ int32_t KvStoreDataService::OnScreenUnlocked(int32_t user) int32_t KvStoreDataService::ClearAppStorage(const std::string &bundleName, int32_t userId, int32_t appIndex, int32_t tokenId) { - BundleMgrAdapter::GetInstance().DeleteCache(bundleName, userId); + CheckerManager::GetInstance().DeleteCache(bundleName, userId, appIndex); auto callerToken = IPCSkeleton::GetCallingTokenID(); NativeTokenInfo nativeTokenInfo; if (AccessTokenKit::GetNativeTokenInfo(callerToken, nativeTokenInfo) != RET_SUCCESS || diff --git a/services/distributeddataservice/framework/checker/checker_manager.cpp b/services/distributeddataservice/framework/checker/checker_manager.cpp index e02f50c64..739ff5ce6 100644 --- a/services/distributeddataservice/framework/checker/checker_manager.cpp +++ b/services/distributeddataservice/framework/checker/checker_manager.cpp @@ -47,6 +47,26 @@ void CheckerManager::RegisterPlugin(const std::string &checker, std::functionDeleteCache(bundleName, user, index); + } +} + +void CheckerManager::ClearCache() +{ + for (auto &[name, checker] : checkers_) { + if (checker == nullptr) { + continue; + } + checker->ClearCache(); + } +} + std::string CheckerManager::GetAppId(const StoreInfo &info) { for (auto &[name, checker] : checkers_) { diff --git a/services/distributeddataservice/framework/include/checker/checker_manager.h b/services/distributeddataservice/framework/include/checker/checker_manager.h index b0ad878e1..f42f43c61 100644 --- a/services/distributeddataservice/framework/include/checker/checker_manager.h +++ b/services/distributeddataservice/framework/include/checker/checker_manager.h @@ -53,6 +53,8 @@ public: virtual std::vector GetStaticStores() = 0; virtual bool IsDynamic(const StoreInfo &info) = 0; virtual bool IsStatic(const StoreInfo &info) = 0; + virtual void DeleteCache(const std::string &bundleName, int32_t user, int32_t index){}; + virtual void ClearCache(){}; protected: API_EXPORT ~Checker() = default; }; @@ -68,6 +70,8 @@ public: API_EXPORT bool IsSwitches(const StoreInfo &info); API_EXPORT void LoadCheckers(std::vector &checkers); API_EXPORT Checker *GetChecker(const std::string &checker); + API_EXPORT void DeleteCache(const std::string &bundleName, int32_t user, int32_t index); + API_EXPORT void ClearCache(); private: std::map checkers_; diff --git a/services/distributeddataservice/framework/test/BUILD.gn b/services/distributeddataservice/framework/test/BUILD.gn index 2f754c7c1..37a5bafdd 100644 --- a/services/distributeddataservice/framework/test/BUILD.gn +++ b/services/distributeddataservice/framework/test/BUILD.gn @@ -366,7 +366,6 @@ ohos_unittest("ServiceMetaDataTest") { deps = [ "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/bundle_mgr:distributedata_bundlemgr", "${data_service_path}/adapter/communicator:distributeddata_communicator", "${data_service_path}/adapter/utils:distributeddata_utils", "${data_service_path}/app/src/checker:distributeddata_checker", diff --git a/services/distributeddataservice/service/BUILD.gn b/services/distributeddataservice/service/BUILD.gn index b0cfab377..799699962 100644 --- a/services/distributeddataservice/service/BUILD.gn +++ b/services/distributeddataservice/service/BUILD.gn @@ -71,7 +71,6 @@ ohos_shared_library("distributeddatasvc") { deps = [ "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/bundle_mgr:distributedata_bundlemgr", "${data_service_path}/adapter/communicator:distributeddata_communicator", "${data_service_path}/adapter/dfx:distributeddata_dfx", "${data_service_path}/adapter/network:distributeddata_network", diff --git a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn index e40e04ef3..398162fcc 100644 --- a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn @@ -44,7 +44,6 @@ ohos_fuzztest("UdmfServiceFuzzTest") { deps = [ "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/bundle_mgr:distributedata_bundlemgr", "${data_service_path}/adapter/communicator:distributeddata_communicator", "${data_service_path}/adapter/dfx:distributeddata_dfx", "${data_service_path}/framework:distributeddatasvcfwk", diff --git a/services/distributeddataservice/service/udmf/BUILD.gn b/services/distributeddataservice/service/udmf/BUILD.gn index d1d7d3889..6ac317304 100644 --- a/services/distributeddataservice/service/udmf/BUILD.gn +++ b/services/distributeddataservice/service/udmf/BUILD.gn @@ -17,7 +17,6 @@ config("module_public_config") { visibility = [ ":*" ] include_dirs = [ - "${data_service_path}/adapter/include", "${data_service_path}/adapter/include/communicator", "${data_service_path}/service/matrix/include", "${data_service_path}/service/permission/include", diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index f50c0f1c1..35610a086 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -23,6 +23,7 @@ #include "dds_trace.h" #include "udmf_radar_reporter.h" #include "accesstoken_kit.h" +#include "checker/checker_manager.h" #include "device_manager_adapter.h" #include "file_mount_manager.h" #include "iservice_registry.h" @@ -33,7 +34,6 @@ #include "utils/crypto.h" #include "uri_permission_manager_client.h" #include "ipc_skeleton.h" -#include "bundle_mgr/bundlemgr_adapter.h" namespace OHOS { namespace UDMF { static constexpr int ID_LEN = 32; @@ -71,8 +71,7 @@ int32_t PreProcessUtils::FillRuntimeInfo(UnifiedData &data, CustomOption &option UnifiedKey key(intention, bundleName, GenerateId()); Privilege privilege; privilege.tokenId = option.tokenId; - int32_t userId = IPCSkeleton::GetCallingUid() / OHOS::AppExecFwk::Constants::BASE_USER_RANGE; - std::string appId = DistributedData::BundleMgrAdapter::GetInstance().GetBundleAppId(bundleName, userId); + std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId({IPCSkeleton::GetCallingUid(), option.tokenId, bundleName}); Runtime runtime; runtime.key = key; runtime.privileges.emplace_back(privilege); diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 770a10c31..310ed23af 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -25,6 +25,7 @@ #include "bootstrap.h" #include "bundle_info.h" #include "bundlemgr/bundle_mgr_proxy.h" +#include "checker/checker_manager.h" #include "checker_manager.h" #include "device_manager_adapter.h" #include "device_matrix.h" @@ -43,7 +44,6 @@ #include "unified_data_helper.h" #include "utils/anonymous.h" #include "permission_validator.h" -#include "bundle_mgr/bundlemgr_adapter.h" namespace OHOS { namespace UDMF { @@ -468,8 +468,7 @@ int32_t UdmfServiceImpl::CheckAppId(std::shared_ptr runtime, const std: ZLOGE("Update failed: Invalid parameter, runtime->appId is empty"); return E_INVALID_PARAMETERS; } - int32_t userId = IPCSkeleton::GetCallingUid() / OHOS::AppExecFwk::Constants::BASE_USER_RANGE; - std::string appId = BundleMgrAdapter::GetInstance().GetBundleAppId(bundleName, userId); + std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId({IPCSkeleton::GetCallingUid(), runtime->tokenId, bundleName}); if (appId.empty() || appId != runtime->appId) { ZLOGE("Update failed: runtime->appId %{public}s and bundleName appId %{public}s mismatch", runtime->appId.c_str(), appId.c_str()); -- Gitee From 0402ebe281769fb720b5ef39feb02a7f968be73d Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Fri, 15 Aug 2025 15:08:34 +0800 Subject: [PATCH 02/76] fix appid Signed-off-by: wenjinchao Change-Id: Ifc575af784c4afa7a6bd6e748c500431cfeaaac1 --- .../service/udmf/preprocess/preprocess_utils.cpp | 3 ++- .../distributeddataservice/service/udmf/udmf_service_impl.cpp | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 35610a086..96b64cd42 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -71,7 +71,8 @@ int32_t PreProcessUtils::FillRuntimeInfo(UnifiedData &data, CustomOption &option UnifiedKey key(intention, bundleName, GenerateId()); Privilege privilege; privilege.tokenId = option.tokenId; - std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId({IPCSkeleton::GetCallingUid(), option.tokenId, bundleName}); + std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId( + { IPCSkeleton::GetCallingUid(), option.tokenId, bundleName }); Runtime runtime; runtime.key = key; runtime.privileges.emplace_back(privilege); diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 310ed23af..2846d8285 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -468,7 +468,8 @@ int32_t UdmfServiceImpl::CheckAppId(std::shared_ptr runtime, const std: ZLOGE("Update failed: Invalid parameter, runtime->appId is empty"); return E_INVALID_PARAMETERS; } - std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId({IPCSkeleton::GetCallingUid(), runtime->tokenId, bundleName}); + std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId( + { IPCSkeleton::GetCallingUid(), runtime->tokenId, bundleName }); if (appId.empty() || appId != runtime->appId) { ZLOGE("Update failed: runtime->appId %{public}s and bundleName appId %{public}s mismatch", runtime->appId.c_str(), appId.c_str()); -- Gitee From bfd191543216756eb1ad300e14d14a7fe928dca4 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Sat, 16 Aug 2025 18:31:09 +0800 Subject: [PATCH 03/76] fix appid Signed-off-by: wenjinchao Change-Id: I17801c60e3a98f3c73222c4da5a491ee88607f6e --- .../distributeddataservice/app/test/BUILD.gn | 25 ++++ .../app/test/unittest/bundle_checker_test.cpp | 120 ++++++++++++++++++ 2 files changed, 145 insertions(+) create mode 100644 services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp diff --git a/services/distributeddataservice/app/test/BUILD.gn b/services/distributeddataservice/app/test/BUILD.gn index 80725c641..d79c567b8 100644 --- a/services/distributeddataservice/app/test/BUILD.gn +++ b/services/distributeddataservice/app/test/BUILD.gn @@ -560,6 +560,30 @@ ohos_unittest("RouteHeadHandlerImplTest") { part_name = "datamgr_service" } +ohos_unittest("BundleCheckerTest") { + module_out_path = module_output_path + sources = [ "unittest/bundle_checker_test.cpp" ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "c_utils:utils", + "googletest:gtest_main", + "hilog:libhilog", + "ipc:ipc_core", + "kv_store:distributeddata_inner", + "openssl:libcrypto_shared", + ] + + deps = [ + "${data_service_path}/app/src/checker:distributeddata_checker", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + ] +} + ############################################################################### group("unittest") { @@ -567,6 +591,7 @@ group("unittest") { deps = [] deps += [ + ":BundleCheckerTest", ":FeatureStubImplTest", ":KvStoreDataServiceClearTest", ":KvStoreDataServiceTest", diff --git a/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp new file mode 100644 index 000000000..965967806 --- /dev/null +++ b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp @@ -0,0 +1,120 @@ +/* +* Copyright (c) 2022 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. +*/ + +#include +#include "accesstoken_kit.h" +#include "checker/bundle_checker.h" +#include "bootstrap.h" +#include "hap_token_info.h" +#include "nativetoken_kit.h" +#include "utils/crypto.h" +#include "utils/crypto.h" +using namespace testing::ext; +using namespace OHOS::DistributedData; +using namespace OHOS::Security::AccessToken; +class BundleCheckerTest : public testing::Test { +public: + static void SetUpTestCase(void) {} + static void TearDownTestCase(void) {} + void SetUp(); + void TearDown(); + NativeTokenInfoParams infoInstance{0}; +}; + +void BundleCheckerTest::SetUp(void) +{ + infoInstance.dcapsNum = 0; + infoInstance.permsNum = 0; + infoInstance.aclsNum = 0; + infoInstance.dcaps = nullptr; + infoInstance.perms = nullptr; + infoInstance.acls = nullptr; + infoInstance.processName = "BundleCheckerTest"; + infoInstance.aplStr = "system_core"; + + HapInfoParams info = { + .userID = 100, + .bundleName = "com.ohos.dlpmanager", + .instIndex = 0, + .appIDDesc = "com.ohos.dlpmanager" + }; + PermissionDef infoManagerTestPermDef = { + .permissionName = "ohos.permission.test", + .bundleName = "ohos.test.demo", + .grantMode = 1, + .availableLevel = APL_NORMAL, + .label = "label", + .labelId = 1, + .description = "open the door", + .descriptionId = 1 + }; + PermissionStateFull infoManagerTestState = { + .permissionName = "ohos.permission.test", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {1} + }; + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {infoManagerTestPermDef}, + .permStateList = {infoManagerTestState} + }; + AccessTokenKit::AllocHapToken(info, policy); + + Bootstrap::GetInstance().LoadComponents(); + Bootstrap::GetInstance().LoadDirectory(); + Bootstrap::GetInstance().LoadCheckers(); + Bootstrap::GetInstance().LoadNetworks(); +} + +void BundleCheckerTest::TearDown() +{ + auto tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.dlpmanager", 0); + AccessTokenKit::DeleteToken(tokenId); +} + +/** +* @tc.name: SystemChecker bms +* @tc.desc: checker the bundle name of the system abilities. +* @tc.type: FUNC +* @tc.require: +* @tc.author: Sven Wang +*/ +HWTEST_F(BundleCheckerTest, SystemCheckerBMS, TestSize.Level0) +{ + CheckerManager::StoreInfo info; + auto tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.dlpmanager", 0); + info.uid = 100 * 200000; + info.tokenId = tokenId; + info.bundleName = "com.ohos.dlpmanager"; + BundleChecker checker; + std::string appIdInCache; + ASSERT_TRUE(!checker.GetAppId(info).empty()); + checker.appIds_.Get("com.ohos.dlpmanager###100", appIdInCache); + ASSERT_TRUE(!appIdInCache.empty()); + ASSERT_EQ(Crypto::Sha256(appIdInCache), checker.GetAppId(info)); + + checker.DeleteCache(info.bundleName, 100, 0); + std::string appIdInCache1; + checker.appIds_.Get("com.ohos.dlpmanager###100", appIdInCache1); + ASSERT_TRUE(appIdInCache1.empty()); + + checker.GetAppId(info); + ASSERT_GE(checker.appIds_.Size(), 1); + checker.ClearCache(); + ASSERT_EQ(checker.appIds_.Size(), 0); +} \ No newline at end of file -- Gitee From fa5a83f54a3d2208369c7b9dc6edcf1bdbf010e3 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Sat, 16 Aug 2025 18:32:58 +0800 Subject: [PATCH 04/76] fix appid Signed-off-by: wenjinchao Change-Id: I916a760ba0edc66f03c96c4cdde7cb64b9b5733b --- .../app/test/unittest/bundle_checker_test.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp index 965967806..8770b0fce 100644 --- a/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp +++ b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp @@ -1,5 +1,5 @@ /* -* Copyright (c) 2022 Huawei Device Co., Ltd. +* Copyright (c) 2025 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 @@ -20,7 +20,6 @@ #include "hap_token_info.h" #include "nativetoken_kit.h" #include "utils/crypto.h" -#include "utils/crypto.h" using namespace testing::ext; using namespace OHOS::DistributedData; using namespace OHOS::Security::AccessToken; @@ -88,13 +87,12 @@ void BundleCheckerTest::TearDown() } /** -* @tc.name: SystemChecker bms -* @tc.desc: checker the bundle name of the system abilities. +* @tc.name: GetAppIdTest001 +* @tc.desc: get appId from cache. * @tc.type: FUNC * @tc.require: -* @tc.author: Sven Wang */ -HWTEST_F(BundleCheckerTest, SystemCheckerBMS, TestSize.Level0) +HWTEST_F(BundleCheckerTest, GetAppIdTest001, TestSize.Level0) { CheckerManager::StoreInfo info; auto tokenId = AccessTokenKit::GetHapTokenID(100, "com.ohos.dlpmanager", 0); -- Gitee From 9b22bd2e547f4035cb3d63d497faba5be12d11f5 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Sat, 16 Aug 2025 19:07:53 +0800 Subject: [PATCH 05/76] fix appid Signed-off-by: wenjinchao Change-Id: I6bc74a09d428c4fc7e54333e7cd052bbf47d94e7 --- .../service/test/mock/preprocess_utils_mock.cpp | 4 +++- .../service/test/mock/preprocess_utils_mock.h | 3 ++- .../test/udmf_preprocess_utils_mock_test.cpp | 9 ++++++--- .../service/udmf/preprocess/preprocess_utils.cpp | 10 ++++++---- .../service/udmf/preprocess/preprocess_utils.h | 3 ++- .../service/udmf/udmf_service_impl.cpp | 13 ++++++++----- 6 files changed, 27 insertions(+), 15 deletions(-) diff --git a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp index 7b7e648f1..c1d117dda 100644 --- a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp +++ b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp @@ -188,8 +188,10 @@ bool PreProcessUtils::GetSpecificBundleName(const std::string &bundleName, int32 return true; } -bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &bundleName) +bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, + std::string &bundleName) { + specificBundleName = "specificBundleName"; bundleName = "bundleName"; return true; } diff --git a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h index e79e2bb6c..92af6e73e 100644 --- a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h +++ b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h @@ -43,7 +43,8 @@ public: static void SetRecordUid(UnifiedData &data); static bool GetDetailsFromUData(const UnifiedData &data, UDDetails &details); static Status GetSummaryFromDetails(const UDDetails &details, Summary &summary); - static bool GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &bundleName); + static bool GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, + std::string &bundleName); static std::string GetAppId(const std::string &bundleName); static sptr GetBundleMgr(); }; diff --git a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp index 93ea1516b..b09a55fff 100644 --- a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp +++ b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp @@ -88,8 +88,9 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId001, TestSi EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_SHELL)); std::string bundleName = ""; + std::string specificBundleName = ""; PreProcessUtils preProcessUtils; - bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, bundleName); + bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName); EXPECT_EQ(ret, false); } @@ -106,8 +107,9 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId002, TestSi EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_NATIVE)); EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); std::string bundleName = ""; + std::string specificBundleName = ""; PreProcessUtils preProcessUtils; - bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, bundleName); + bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName); EXPECT_EQ(ret, true); } @@ -122,8 +124,9 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId003, TestSi uint32_t tokenId = 9999; EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); std::string bundleName = ""; + std::string specificBundleName = ""; PreProcessUtils preProcessUtils; - bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, bundleName); + bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName); EXPECT_EQ(ret, true); } }; // namespace UDMF \ No newline at end of file diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 96b64cd42..7abb1dcd6 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -63,12 +63,13 @@ int32_t PreProcessUtils::FillRuntimeInfo(UnifiedData &data, CustomOption &option return E_ERROR; } std::string bundleName; - if (!GetSpecificBundleNameByTokenId(option.tokenId, bundleName)) { + std::string specificBundleName; + if (!GetSpecificBundleNameByTokenId(option.tokenId, specificBundleName, bundleName)) { ZLOGE("GetSpecificBundleNameByTokenId failed, tokenid:%{public}u", option.tokenId); return E_ERROR; } std::string intention = it->second; - UnifiedKey key(intention, bundleName, GenerateId()); + UnifiedKey key(intention, specificBundleName, GenerateId()); Privilege privilege; privilege.tokenId = option.tokenId; std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId( @@ -500,12 +501,13 @@ std::string PreProcessUtils::GetSdkVersionByToken(uint32_t tokenId) return std::to_string(hapTokenInfo.apiVersion); } -bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &bundleName) +bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, std::string &bundleName) { Security::AccessToken::HapTokenInfo hapInfo; if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { - return GetSpecificBundleName(hapInfo.bundleName, hapInfo.instIndex, bundleName); + bundleName = hapInfo.bundleName; + return GetSpecificBundleName(hapInfo.bundleName, hapInfo.instIndex, specificBundleName); } if (UTILS::IsTokenNative()) { ZLOGI("TypeATokenTypeEnum is TOKEN_NATIVE"); diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h index 8cd126f55..8c3867e0f 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h @@ -43,7 +43,8 @@ public: static void SetRecordUid(UnifiedData &data); static bool GetDetailsFromUData(const UnifiedData &data, UDDetails &details); static Status GetSummaryFromDetails(const UDDetails &details, Summary &summary); - static bool GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &bundleName); + static bool GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, + std::string & bundleName); static sptr GetBundleMgr(); private: static bool CheckUriAuthorization(const std::vector& uris, uint32_t tokenId); diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 2846d8285..0df88fa22 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -417,11 +417,12 @@ int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifi return E_INVALID_PARAMETERS; } std::string bundleName; - if (!PreProcessUtils::GetSpecificBundleNameByTokenId(query.tokenId, bundleName)) { + std::string specificBundleName; + if (!PreProcessUtils::GetSpecificBundleNameByTokenId(query.tokenId, specificBundleName, bundleName)) { ZLOGE("GetSpecificBundleNameByTokenId failed, tokenid:%{public}u", query.tokenId); return E_ERROR; } - if (key.bundleName != bundleName && !HasDatahubPriviledge(bundleName)) { + if (key.bundleName != specificBundleName && !HasDatahubPriviledge(bundleName)) { ZLOGE("update data failed by %{public}s, key: %{public}s.", bundleName.c_str(), query.key.c_str()); return E_INVALID_PARAMETERS; } @@ -538,7 +539,8 @@ bool UdmfServiceImpl::CheckDeleteDataPermission(std::string &appId, const std::s return true; } std::string bundleName; - if (!PreProcessUtils::GetSpecificBundleNameByTokenId(query.tokenId, bundleName)) { + std::string specificBundleName; + if (!PreProcessUtils::GetSpecificBundleNameByTokenId(query.tokenId, specificBundleName, bundleName)) { ZLOGE("GetSpecificBundleNameByTokenId failed, tokenid:%{public}u", query.tokenId); return false; } @@ -1156,12 +1158,13 @@ bool UdmfServiceImpl::IsValidOptionsNonDrag(UnifiedKey &key, const std::string & int32_t UdmfServiceImpl::SetDelayInfo(const DataLoadInfo &dataLoadInfo, sptr iUdmfNotifier, std::string &key) { std::string bundleName; + std::string specificBundleName; auto tokenId = static_cast(IPCSkeleton::GetCallingTokenID()); - if (!PreProcessUtils::GetSpecificBundleNameByTokenId(tokenId, bundleName)) { + if (!PreProcessUtils::GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName)) { ZLOGE("GetSpecificBundleNameByTokenId failed, tokenid:%{public}u", tokenId); return E_ERROR; } - UnifiedKey udkey(UD_INTENTION_MAP.at(UD_INTENTION_DRAG), bundleName, dataLoadInfo.sequenceKey); + UnifiedKey udkey(UD_INTENTION_MAP.at(UD_INTENTION_DRAG), specificBundleName, dataLoadInfo.sequenceKey); key = udkey.GetUnifiedKey(); dataLoadCallback_.Insert(key, iface_cast(iUdmfNotifier)); -- Gitee From 42e9d4687981263adac4d3b23884962dab366ddf Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Mon, 18 Aug 2025 10:37:53 +0800 Subject: [PATCH 06/76] fix appid Signed-off-by: wenjinchao Change-Id: I9fef6562314ff5b5fd6db18978a6a918ef84733e --- .../udmf/preprocess/preprocess_utils.cpp | 3 +- .../udmf/preprocess/preprocess_utils.h | 2 +- .../service/udmf/udmf_service_impl.cpp | 29 +++++++++++++------ .../service/udmf/udmf_service_impl.h | 1 + 4 files changed, 24 insertions(+), 11 deletions(-) diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 7abb1dcd6..17e8915f9 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -501,7 +501,8 @@ std::string PreProcessUtils::GetSdkVersionByToken(uint32_t tokenId) return std::to_string(hapTokenInfo.apiVersion); } -bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, std::string &bundleName) +bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, + std::string &bundleName) { Security::AccessToken::HapTokenInfo hapInfo; if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h index 8c3867e0f..e378592c8 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h @@ -44,7 +44,7 @@ public: static bool GetDetailsFromUData(const UnifiedData &data, UDDetails &details); static Status GetSummaryFromDetails(const UDDetails &details, Summary &summary); static bool GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, - std::string & bundleName); + std::string &bundleName); static sptr GetBundleMgr(); private: static bool CheckUriAuthorization(const std::vector& uris, uint32_t tokenId); diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 0df88fa22..36e4deba5 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -438,8 +438,27 @@ int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifi HandleDbError(key.intention, res); return res; } + auto verifyRes = VerifyUpdatePermission(query, data, bundleName); + if (verifyRes != E_OK) { + ZLOGE("VerifyUpdatePermission failed:%{public}d, key: %{public}s.", verifyRes, query.key.c_str()); + return verifyRes; + } + std::shared_ptr runtime = data.GetRuntime(); + runtime->lastModifiedTime = PreProcessUtils::GetTimestamp(); + unifiedData.SetRuntime(*runtime); + PreProcessUtils::SetRecordUid(unifiedData); + if ((res = store->Update(unifiedData)) != E_OK) { + ZLOGE("Unified data update failed:%{public}s", key.intention.c_str()); + HandleDbError(key.intention, res); + return E_DB_ERROR; + } + return E_OK; +} + +int32_t UdmfServiceImpl::VerifyUpdatePermission(const QueryOption &query, UnifiedData &data, std::string &bundleName) +{ if (data.IsEmpty()) { - ZLOGE("Invalid parameter, unified data has no record; intention: %{public}s.", key.intention.c_str()); + ZLOGE("Invalid parameter, unified data has no record"); return E_INVALID_PARAMETERS; } std::shared_ptr runtime = data.GetRuntime(); @@ -452,14 +471,6 @@ int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifi ZLOGE("Update failed: tokenId or appId mismatch, bundleName: %{public}s", bundleName.c_str()); return E_INVALID_PARAMETERS; } - runtime->lastModifiedTime = PreProcessUtils::GetTimestamp(); - unifiedData.SetRuntime(*runtime); - PreProcessUtils::SetRecordUid(unifiedData); - if ((res = store->Update(unifiedData)) != E_OK) { - ZLOGE("Unified data update failed:%{public}s", key.intention.c_str()); - HandleDbError(key.intention, res); - return E_DB_ERROR; - } return E_OK; } diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.h b/services/distributeddataservice/service/udmf/udmf_service_impl.h index 8b03412f1..0260d75fd 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.h +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.h @@ -91,6 +91,7 @@ private: const UnifiedData &unifiedData); std::vector ProcessResult(const std::map &results); DistributedData::StoreMetaData BuildMeta(const std::string &storeId, int userId); + int32_t VerifyUpdatePermission(const QueryOption &query, UnifiedData &unifiedData, std::string &bundleName); class Factory { public: -- Gitee From 3c107665f8b30731a8406a221d268ded621a1eb0 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Mon, 18 Aug 2025 14:19:33 +0800 Subject: [PATCH 07/76] fix appid Signed-off-by: wenjinchao Change-Id: Ie53fcf09a4e40adff8859c93e624178fd67305fa --- .../service/udmf/preprocess/preprocess_utils.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 17e8915f9..597cc9a7a 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -515,6 +515,7 @@ bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::stri std::string processName; if (GetNativeProcessNameByToken(tokenId, processName)) { bundleName = std::move(processName); + specificBundleName = bundleName; return true; } } -- Gitee From a590e6f392877bf38e2df856af061324aa89bbae Mon Sep 17 00:00:00 2001 From: yangliu Date: Mon, 18 Aug 2025 16:22:35 +0800 Subject: [PATCH 08/76] update Signed-off-by: yangliu --- .../adapter/dfx/src/hiview_adapter.cpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp b/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp index f6a82fe28..35e0ceaff 100644 --- a/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp +++ b/services/distributeddataservice/adapter/dfx/src/hiview_adapter.cpp @@ -135,6 +135,7 @@ void HiViewAdapter::ReportDBFault(int dfxCode, const DBFaultMsg &msg, std::share return; } ExecutorPool::Task task([dfxCode, msg]() { + std::string storeId = Anonymous::Change(msg.storeId); struct HiSysEventParam params[] = { { .name = { *APP_ID }, .t = HISYSEVENT_STRING, @@ -142,7 +143,7 @@ void HiViewAdapter::ReportDBFault(int dfxCode, const DBFaultMsg &msg, std::share .arraySize = 0 }, { .name = { *STORE_ID }, .t = HISYSEVENT_STRING, - .v = { .s = const_cast(Anonymous::Change(msg.storeId).c_str()) }, + .v = { .s = const_cast(storeId.c_str()) }, .arraySize = 0 }, { .name = { *MODULE_NAME }, .t = HISYSEVENT_STRING, @@ -172,6 +173,7 @@ void HiViewAdapter::ReportCommFault(int dfxCode, const CommFaultMsg &msg, std::s } ExecutorPool ::Task task([dfxCode, msg]() { std::string message; + std::string storeId = Anonymous::Change(msg.storeId); for (size_t i = 0; i < msg.deviceId.size(); i++) { message.append("No: ").append(std::to_string(i)) .append(" sync to device: ").append(msg.deviceId[i]) @@ -188,7 +190,7 @@ void HiViewAdapter::ReportCommFault(int dfxCode, const CommFaultMsg &msg, std::s .arraySize = 0 }, { .name = { *STORE_ID }, .t = HISYSEVENT_STRING, - .v = { .s = const_cast(Anonymous::Change(msg.storeId).c_str()) }, + .v = { .s = const_cast(storeId.c_str()) }, .arraySize = 0 }, { .name = { *SYNC_ERROR_INFO }, .t = HISYSEVENT_STRING, @@ -244,6 +246,7 @@ void HiViewAdapter::ReportBehaviour(int dfxCode, const BehaviourMsg &msg, std::s } ExecutorPool::Task task([dfxCode, msg]() { std::string message; + std::string storeId = Anonymous::Change(msg.storeId); message.append("Behaviour type : ").append(std::to_string(static_cast(msg.behaviourType))) .append(" behaviour info : ").append(msg.extensionInfo); struct HiSysEventParam params[] = { @@ -257,7 +260,7 @@ void HiViewAdapter::ReportBehaviour(int dfxCode, const BehaviourMsg &msg, std::s .arraySize = 0 }, { .name = { *STORE_ID }, .t = HISYSEVENT_STRING, - .v = { .s = const_cast(Anonymous::Change(msg.storeId).c_str()) }, + .v = { .s = const_cast(storeId.c_str()) }, .arraySize = 0 }, { .name = { *BEHAVIOUR_INFO }, .t = HISYSEVENT_STRING, @@ -303,7 +306,7 @@ void HiViewAdapter::ReportDbSize(const StatisticWrap &stat) if (!vh.CalcValueHash(stat.val.userId, userId)) { return; } - + std::string storeId = Anonymous::Change(stat.val.storeId); struct HiSysEventParam params[] = { { .name = { *USER_ID }, .t = HISYSEVENT_STRING, @@ -315,7 +318,7 @@ void HiViewAdapter::ReportDbSize(const StatisticWrap &stat) .arraySize = 0 }, { .name = { *STORE_ID }, .t = HISYSEVENT_STRING, - .v = { .s = const_cast(Anonymous::Change(stat.val.storeId).c_str()) }, + .v = { .s = const_cast(storeId.c_str()) }, .arraySize = 0 }, { .name = { *DB_SIZE }, .t = HISYSEVENT_UINT64, .v = { .ui64 = dbSize }, .arraySize = 0 }, }; @@ -384,6 +387,7 @@ void HiViewAdapter::InvokeTraffic() if (!vh.CalcValueHash(kv.second.val.deviceId, deviceId)) { continue; } + std::string devId = Anonymous::Change(deviceId); struct HiSysEventParam params[] = { { .name = { *TAG }, .t = HISYSEVENT_STRING, .v = { .s = const_cast(POWERSTATS) }, .arraySize = 0 }, { .name = { *APP_ID }, @@ -392,7 +396,7 @@ void HiViewAdapter::InvokeTraffic() .arraySize = 0 }, { .name = { *DEVICE_ID }, .t = HISYSEVENT_STRING, - .v = { .s = const_cast(Anonymous::Change(deviceId).c_str()) }, + .v = { .s = const_cast(devId.c_str()) }, .arraySize = 0 }, { .name = { *SEND_SIZE }, .t = HISYSEVENT_INT64, -- Gitee From 165fb26f13e00159cb92e97692f7ce70acf07af6 Mon Sep 17 00:00:00 2001 From: wenjinchao Date: Mon, 18 Aug 2025 16:47:22 +0800 Subject: [PATCH 09/76] fix appid Signed-off-by: wenjinchao Change-Id: Ib85cea627b7782044d77807b0de8ab4a1c72fe14 --- .../distributeddataservice/app/src/checker/bundle_checker.h | 2 +- .../app/test/unittest/bundle_checker_test.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.h b/services/distributeddataservice/app/src/checker/bundle_checker.h index a7b07159c..d5c655bb9 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.h +++ b/services/distributeddataservice/app/src/checker/bundle_checker.h @@ -50,7 +50,7 @@ private: std::vector dynamicStores_; std::vector staticStores_; std::string GetBundleAppId(const CheckerManager::StoreInfo &info); - LRUBucket appIds_ {CACHE_SIZE}; + LRUBucket appIds_ { CACHE_SIZE }; }; } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp index 8770b0fce..deb5c7def 100644 --- a/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp +++ b/services/distributeddataservice/app/test/unittest/bundle_checker_test.cpp @@ -103,7 +103,7 @@ HWTEST_F(BundleCheckerTest, GetAppIdTest001, TestSize.Level0) std::string appIdInCache; ASSERT_TRUE(!checker.GetAppId(info).empty()); checker.appIds_.Get("com.ohos.dlpmanager###100", appIdInCache); - ASSERT_TRUE(!appIdInCache.empty()); + ASSERT_FALSE(appIdInCache.empty()); ASSERT_EQ(Crypto::Sha256(appIdInCache), checker.GetAppId(info)); checker.DeleteCache(info.bundleName, 100, 0); -- Gitee From f701171266d0822e05d96dd9f6cdfdb102101745 Mon Sep 17 00:00:00 2001 From: wangbin Date: Mon, 18 Aug 2025 15:53:41 +0800 Subject: [PATCH 10/76] =?UTF-8?q?fix=20=E4=B8=80=E8=87=B4=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangbin --- .../fuzztest/softbusadapter_fuzzer/BUILD.gn | 12 +++- .../screenlock/test/screen_lock_test.cpp | 55 +++++++++++++++++++ .../service/test/kvdb_general_store_test.cpp | 41 +++++++------- 3 files changed, 87 insertions(+), 21 deletions(-) diff --git a/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn b/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn index 54392bfff..b3c1e7279 100644 --- a/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn +++ b/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn @@ -35,7 +35,17 @@ ohos_fuzztest("SoftBusAdapterFuzzTest") { "-fno-omit-frame-pointer", ] - sources = [ "softbusadapter_fuzzer.cpp" ] + sources = [ + "${data_service_path}/adapter/communicator/src/communicator_context.cpp", + "${data_service_path}/adapter/communicator/src/device_manager_adapter.cpp", + "${data_service_path}/adapter/communicator/src/softbus_client.cpp", + "softbusadapter_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + ] external_deps = [ "access_token:libaccesstoken_sdk", diff --git a/services/distributeddataservice/adapter/screenlock/test/screen_lock_test.cpp b/services/distributeddataservice/adapter/screenlock/test/screen_lock_test.cpp index 9374568e5..5384155bc 100644 --- a/services/distributeddataservice/adapter/screenlock/test/screen_lock_test.cpp +++ b/services/distributeddataservice/adapter/screenlock/test/screen_lock_test.cpp @@ -53,6 +53,8 @@ public: void TearDown() { } +protected: + static constexpr int32_t MAX_RETRY_TIME = 300; }; /** @@ -125,4 +127,57 @@ HWTEST_F(ScreenLockTest, SubscribeScreenEvent001, TestSize.Level0) screenLock->UnsubscribeScreenEvent(); screenLock->executors_ = nullptr; } + +/** +* @tc.name: SubscribeScreenEvent002 +* @tc.desc: subscribe ScreenEvent +* @tc.type: FUNC +* @tc.author: +*/ +HWTEST_F(ScreenLockTest, SubscribeScreenEvent002, TestSize.Level0) +{ + auto screenLock = std::make_shared(); + EXPECT_EQ(screenLock->executors_, nullptr); + EXPECT_EQ(screenLock->eventSubscriber_, nullptr); + screenLock->SubscribeScreenEvent(); + EXPECT_NE(screenLock->eventSubscriber_, nullptr); + screenLock->UnsubscribeScreenEvent(); +} + +/** +* @tc.name: GetTask001 +* @tc.desc: subscribe ScreenEvent +* @tc.type: FUNC +* @tc.author: +*/ +HWTEST_F(ScreenLockTest, GetTask001, TestSize.Level0) +{ + auto screenLock = std::make_shared(); + EXPECT_EQ(screenLock->executors_, nullptr); + EXPECT_EQ(screenLock->eventSubscriber_, nullptr); + auto Task = screenLock->GetTask(0); + Task(); + auto executor = std::make_shared(12, 5); + screenLock->BindExecutor(executor); + ASSERT_NE(screenLock->executors_, nullptr); + Task = screenLock->GetTask(MAX_RETRY_TIME - 1); + Task(); +} + +/** +* @tc.name: GetTask002 +* @tc.desc: subscribe ScreenEvent +* @tc.type: FUNC +* @tc.author: +*/ +HWTEST_F(ScreenLockTest, GetTask002, TestSize.Level0) +{ + auto screenLock = std::make_shared(); + EXPECT_EQ(screenLock->executors_, nullptr); + EXPECT_EQ(screenLock->eventSubscriber_, nullptr); + screenLock->SubscribeScreenEvent(); + EXPECT_NE(screenLock->eventSubscriber_, nullptr); + auto Task = screenLock->GetTask(0); + Task(); +} } // namespace \ No newline at end of file diff --git a/services/distributeddataservice/service/test/kvdb_general_store_test.cpp b/services/distributeddataservice/service/test/kvdb_general_store_test.cpp index c34db72a6..3566bb007 100644 --- a/services/distributeddataservice/service/test/kvdb_general_store_test.cpp +++ b/services/distributeddataservice/service/test/kvdb_general_store_test.cpp @@ -59,10 +59,9 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - protected: - static constexpr const char *bundleName = "test_distributeddata"; - static constexpr const char *storeName = "test_service_meta"; + static constexpr const char *BUNDLE_NAME = "test_distributeddata"; + static constexpr const char *STORE_NAME = "test_service_meta"; void InitMetaData(); static std::vector Random(uint32_t len); @@ -76,15 +75,15 @@ static const uint32_t KEY_LENGTH = 32; void KVDBGeneralStoreTest::InitMetaData() { - metaData_.bundleName = bundleName; - metaData_.appId = bundleName; + metaData_.bundleName = BUNDLE_NAME; + metaData_.appId = BUNDLE_NAME; metaData_.user = "0"; metaData_.area = OHOS::DistributedKv::EL1; metaData_.instanceId = 0; metaData_.isAutoSync = true; metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION; - metaData_.storeId = storeName; - metaData_.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb"; + metaData_.storeId = STORE_NAME; + metaData_.dataDir = "/data/service/el1/public/database/" + std::string(BUNDLE_NAME) + "/kvdb"; metaData_.securityLevel = SecurityLevel::S2; } @@ -404,7 +403,7 @@ HWTEST_F(KVDBGeneralStoreTest, BusyClose, TestSize.Level0) HWTEST_F(KVDBGeneralStoreTest, SyncTest, TestSize.Level0) { ZLOGI("SyncTest start"); - mkdir(("/data/service/el1/public/database/" + std::string(bundleName)).c_str(), + mkdir(("/data/service/el1/public/database/" + std::string(BUNDLE_NAME)).c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); @@ -540,14 +539,14 @@ HWTEST_F(KVDBGeneralStoreTest, CloudSync001, TestSize.Level0) { auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); KvStoreNbDelegateMock mockDelegate; store->delegate_ = &mockDelegate; std::vector devices = { "device1", "device2" }; auto asyncs = [](const GenDetails &result) {}; store->storeInfo_.user = 0; auto cloudSyncMode = DistributedDB::SyncMode::SYNC_MODE_PUSH_ONLY; - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); std::string prepareTraceId; std::vector users; EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(users), Return(false))); @@ -568,20 +567,22 @@ HWTEST_F(KVDBGeneralStoreTest, CloudSync002, TestSize.Level0) { auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); KvStoreNbDelegateMock mockDelegate; store->delegate_ = &mockDelegate; std::vector devices = { "device1", "device2" }; auto asyncs = [](const GenDetails &result) {}; store->storeInfo_.user = 0; auto cloudSyncMode = DistributedDB::SyncMode::SYNC_MODE_PUSH_ONLY; - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); std::string prepareTraceId; std::vector users; EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) .Times(1) - .WillOnce( - DoAll(SetArgReferee<0>(users), Invoke([](std::vector &users) { users.clear(); }), Return(true))); + .WillOnce(DoAll( + SetArgReferee<0>(users), + Invoke([](std::vector& users) { users.clear(); }), + Return(true))); auto ret = store->CloudSync(devices, cloudSyncMode, asyncs, 0, prepareTraceId); EXPECT_EQ(ret, DBStatus::DB_ERROR); @@ -604,14 +605,14 @@ HWTEST_F(KVDBGeneralStoreTest, CloudSync003, TestSize.Level0) { auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); KvStoreNbDelegateMock mockDelegate; store->delegate_ = &mockDelegate; std::vector devices = { "device1", "device2" }; auto asyncs = [](const GenDetails &result) {}; store->storeInfo_.user = 0; auto cloudSyncMode = DistributedDB::SyncMode::SYNC_MODE_PUSH_ONLY; - store->SetEqualIdentifier(bundleName, storeName); + store->SetEqualIdentifier(BUNDLE_NAME, STORE_NAME); std::string prepareTraceId; std::vector users = {0, 1}; EXPECT_CALL(*accountDelegateMock, QueryUsers(_)) @@ -654,7 +655,7 @@ HWTEST_F(KVDBGeneralStoreTest, GetIdentifierParams, TestSize.Level0) */ HWTEST_F(KVDBGeneralStoreTest, Sync002, TestSize.Level0) { - mkdir(("/data/service/el1/public/database/" + std::string(bundleName)).c_str(), + mkdir(("/data/service/el1/public/database/" + std::string(BUNDLE_NAME)).c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); @@ -689,7 +690,7 @@ HWTEST_F(KVDBGeneralStoreTest, Sync002, TestSize.Level0) */ HWTEST_F(KVDBGeneralStoreTest, Sync003, TestSize.Level0) { - mkdir(("/data/service/el1/public/database/" + std::string(bundleName)).c_str(), + mkdir(("/data/service/el1/public/database/" + std::string(BUNDLE_NAME)).c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); @@ -974,7 +975,7 @@ HWTEST_F(KVDBGeneralStoreTest, GetDBOption001, TestSize.Level0) */ HWTEST_F(KVDBGeneralStoreTest, Sync001, TestSize.Level0) { - mkdir(("/data/service/el1/public/database/" + std::string(bundleName)).c_str(), + mkdir(("/data/service/el1/public/database/" + std::string(BUNDLE_NAME)).c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)); auto store = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store, nullptr); @@ -1209,7 +1210,7 @@ HWTEST_F(KVDBGeneralStoreTest, ConstructorTest, TestSize.Level0) delete store3; // Test observer registration - metaData_.storeId = storeName; + metaData_.storeId = STORE_NAME; metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION; auto store4 = new (std::nothrow) KVDBGeneralStore(metaData_); ASSERT_NE(store4, nullptr); -- Gitee From b45a8a13243af3e79a361db2e90861b4fa8957e0 Mon Sep 17 00:00:00 2001 From: zph Date: Tue, 19 Aug 2025 10:33:52 +0800 Subject: [PATCH 11/76] update Signed-off-by: zph --- .../service/udmf/udmf_service_impl.cpp | 46 ++++++++++++++----- .../service/udmf/udmf_service_impl.h | 7 +++ 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 668f65a0a..41011805a 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -67,6 +67,7 @@ constexpr const char *DEVICE_PHONE_TAG = "phone"; constexpr const char *DEVICE_DEFAULT_TAG = "default"; constexpr const char *HAP_LIST[] = {"com.ohos.pasteboarddialog"}; constexpr uint32_t FOUNDATION_UID = 5523; +constexpr uint32_t WAIT_TIME = 1; __attribute__((used)) UdmfServiceImpl::Factory UdmfServiceImpl::factory_; UdmfServiceImpl::Factory::Factory() { @@ -174,12 +175,26 @@ int32_t UdmfServiceImpl::GetData(const QueryOption &query, UnifiedData &unifiedD std::string bundleName; if (!PreProcessUtils::GetHapBundleNameByToken(query.tokenId, bundleName)) { msg.appId = "unknown"; - res = E_ERROR; - } else { - msg.appId = bundleName; + Reporter::GetInstance()->GetBehaviourReporter()->UDMFReport(msg); + return E_ERROR; + } + + msg.appId = bundleName; + bool isDelayLoad = dataLoadCallback_.ComputeIfPresent(key, [&unifiedData](auto &key, BlockDelayData &val) { + blockDelayDataCache_.ComputeIfAbsent(query.key, [&query](auto &key) { + auto blockData = std::make_shared>>(WAIT_TIME); + return BlockDelayData { blockData, query.tokenId }; + }); + auto data = val.blockData->GetValue(); + if (data != std::nullopt) { + unifiedData = *data; + return false; + } + return true; + }); + if (!isDelayLoad) { res = RetrieveData(query, unifiedData); } - TransferToEntriesIfNeed(query, unifiedData); auto errFind = ERROR_MAP.find(res); msg.result = errFind == ERROR_MAP.end() ? "E_ERROR" : errFind->second; for (const auto &record : unifiedData.GetRecords()) { @@ -259,6 +274,7 @@ int32_t UdmfServiceImpl::RetrieveData(const QueryOption &query, UnifiedData &uni privilegeCache_.erase(query.key); } PreProcessUtils::SetRemoteData(unifiedData); + TransferToEntriesIfNeed(query, unifiedData); return E_OK; } @@ -1184,6 +1200,12 @@ int32_t UdmfServiceImpl::SetDelayInfo(const DataLoadInfo &dataLoadInfo, sptr(IPCSkeleton::GetCallingTokenID()); @@ -1196,13 +1218,9 @@ int32_t UdmfServiceImpl::PushDelayData(const std::string &key, UnifiedData &unif ZLOGW("SetRemoteUri failed, ret:%{public}d, key:%{public}s.", ret, key.c_str()); } - auto it = delayDataCallback_.Find(key); - if (!it.first) { - ZLOGE("DelayData callback no exist, key:%{public}s", key.c_str()); - return E_ERROR; - } QueryOption query; - query.tokenId = it.second.tokenId; + query.tokenId = isDataLoading ? delayDataCallback_.Find(key).second.tokenId : + blockDelayDataCache_.Find(key).second.tokenId; query.key = key; if (option.tokenId != query.tokenId && !IsPermissionInCache(query)) { ZLOGE("No permission"); @@ -1218,9 +1236,13 @@ int32_t UdmfServiceImpl::PushDelayData(const std::string &key, UnifiedData &unif privilegeCache_.erase(key); } PreProcessUtils::SetRemoteData(unifiedData); - TransferToEntriesIfNeed(query, unifiedData); - return HandleDelayDataCallback(it.second, unifiedData, key); + + if (!isDataLoading) { + blockDelayDataCache_.Find(key).second.blockData->SetValue(unifiedData); + return E_OK; + } + return HandleDelayDataCallback(delayDataCallback_.Find(key).second, unifiedData, key); } int32_t UdmfServiceImpl::HandleDelayDataCallback(DelayGetDataInfo &delayGetDataInfo, UnifiedData &unifiedData, diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.h b/services/distributeddataservice/service/udmf/udmf_service_impl.h index 0dafbfd52..51df264e0 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.h +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.h @@ -22,6 +22,7 @@ #include "metadata/store_meta_data.h" #include "checker_manager.h" #include "udmf_notifier_proxy.h" +#include "block_data.h" namespace OHOS { namespace UDMF { /* @@ -109,6 +110,12 @@ private: std::unordered_map asyncProcessInfoMap_; ConcurrentMap> dataLoadCallback_; ConcurrentMap delayDataCallback_; + + struct BlockDelayData { + std::shared_ptr>> blockData; + uint32_t tokenId; + }; + ConcurrentMap blockDelayDataCache_; }; } // namespace UDMF } // namespace OHOS -- Gitee From 50d90325e5cd391b4b73c6f5ee0fa6be06bf82ba Mon Sep 17 00:00:00 2001 From: zph Date: Tue, 19 Aug 2025 10:47:19 +0800 Subject: [PATCH 12/76] update Signed-off-by: zph --- .../service/udmf/udmf_service_impl.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.h b/services/distributeddataservice/service/udmf/udmf_service_impl.h index 0e14376c5..a738cc04d 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.h +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.h @@ -108,15 +108,15 @@ private: std::shared_ptr executors_; std::mutex mutex_; - std::unordered_map asyncProcessInfoMap_; - ConcurrentMap> dataLoadCallback_; - ConcurrentMap delayDataCallback_; + std::unordered_map asyncProcessInfoMap_ {}; + ConcurrentMap> dataLoadCallback_ {}; + ConcurrentMap delayDataCallback_ {}; struct BlockDelayData { + uint32_t tokenId {0}; std::shared_ptr>> blockData; - uint32_t tokenId; }; - ConcurrentMap blockDelayDataCache_; + ConcurrentMap blockDelayDataCache_ {}; }; } // namespace UDMF } // namespace OHOS -- Gitee From c75f4a1c5e4acfcf74fc2ae0f2c1e502541aa9ad Mon Sep 17 00:00:00 2001 From: wan-xiaoqing321 Date: Tue, 19 Aug 2025 14:58:34 +0800 Subject: [PATCH 13/76] =?UTF-8?q?fuzz=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wan-xiaoqing321 --- .../udmfservice_fuzzer/udmfservice_fuzzer.cpp | 64 +++++++++++++++++-- 1 file changed, 58 insertions(+), 6 deletions(-) diff --git a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp index 59d2290c2..827a48d7c 100644 --- a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp @@ -387,7 +387,10 @@ void OnGetAppShareOptionFuzz(FuzzedDataProvider &provider) { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); MessageParcel requestUpdate; + std::vector remainingData = provider.ConsumeRemainingBytes(); requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN); + requestUpdate.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + requestUpdate.RewindRead(0); CustomOption option = {.intention = Intention::UD_INTENTION_DRAG}; std::string intention = UD_INTENTION_MAP.at(option.intention); ITypesUtil::Marshal(requestUpdate, intention); @@ -658,16 +661,49 @@ void StoreSyncFuzz(FuzzedDataProvider &provider) void SetAppShareOptionFuzz(FuzzedDataProvider &provider) { std::shared_ptr udmfServiceImpl = std::make_shared(); - std::string intention = provider.ConsumeRandomLengthString(); - int32_t shareOption = provider.ConsumeIntegral(); - udmfServiceImpl->SetAppShareOption(intention, shareOption); + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + + MessageParcel requestUpdate; + std::vector remainingData = provider.ConsumeRemainingBytes(); + requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN); + requestUpdate.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + requestUpdate.RewindRead(0); + CustomOption option = {.intention = Intention::UD_INTENTION_DRAG}; + std::string intention = UD_INTENTION_MAP.at(option.intention); + ITypesUtil::Marshal(requestUpdate, intention); + + MessageParcel replyUpdate; + udmfServiceImpl->OnRemoteRequest(static_cast(UdmfServiceInterfaceCode::SET_APP_SHARE_OPTION), + requestUpdate, replyUpdate); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), nullptr }); + executor = nullptr; } void RemoveAppShareOptionFuzz(FuzzedDataProvider &provider) { std::shared_ptr udmfServiceImpl = std::make_shared(); - std::string intention = provider.ConsumeRandomLengthString(); - udmfServiceImpl->RemoveAppShareOption(intention); + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + + MessageParcel requestUpdate; + std::vector remainingData = provider.ConsumeRemainingBytes(); + requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN); + requestUpdate.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + requestUpdate.RewindRead(0); + CustomOption option = {.intention = Intention::UD_INTENTION_DRAG}; + std::string intention = UD_INTENTION_MAP.at(option.intention); + ITypesUtil::Marshal(requestUpdate, intention); + + MessageParcel replyUpdate; + udmfServiceImpl->OnRemoteRequest(static_cast(UdmfServiceInterfaceCode::REMOVE_APP_SHARE_OPTION), + requestUpdate, replyUpdate); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), nullptr }); + executor = nullptr; } void QueryDataCommonFuzz(FuzzedDataProvider &provider) @@ -698,8 +734,24 @@ void QueryDataCommonFuzz(FuzzedDataProvider &provider) void ClearAsynProcessByKeyFuzz(FuzzedDataProvider &provider) { std::shared_ptr udmfServiceImpl = std::make_shared(); + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + + MessageParcel requestUpdate; + std::vector remainingData = provider.ConsumeRemainingBytes(); + requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN); + requestUpdate.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + requestUpdate.RewindRead(0); std::string businessUdKey = provider.ConsumeRandomLengthString(); - udmfServiceImpl->ClearAsynProcessByKey(businessUdKey); + ITypesUtil::Marshal(requestUpdate, businessUdKey); + + MessageParcel replyUpdate; + udmfServiceImpl->OnRemoteRequest(static_cast(UdmfServiceInterfaceCode::CLEAR_ASYN_PROCESS_BY_KEY), + requestUpdate, replyUpdate); + udmfServiceImpl->OnBind( + { "UdmfServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), nullptr }); + executor = nullptr; } void TransferToEntriesIfNeedFuzz(FuzzedDataProvider &provider) -- Gitee From 4be6a1ab16a0a80f20270710b7e73522323eccad Mon Sep 17 00:00:00 2001 From: xuwenqi Date: Wed, 20 Aug 2025 14:49:00 +0800 Subject: [PATCH 14/76] =?UTF-8?q?fuzz=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xuwenqi --- .../datashareserviceimpl_fuzzer.cpp | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/datashareserviceimpl_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/datashareserviceimpl_fuzzer.cpp index 83644b248..a61ead416 100644 --- a/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/datashareserviceimpl_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/datashareserviceimpl_fuzzer.cpp @@ -172,6 +172,8 @@ void TimerReceiverOnReceiveEventFuzz(FuzzedDataProvider &provider) { DataShareServiceImpl::TimerReceiver tmerReceiver; EventFwk::Want want; + std::string action = provider.ConsumeRandomLengthString(); + want.SetAction(action); EventFwk::CommonEventData commonEventData(want); commonEventData.SetWant(want); tmerReceiver.OnReceiveEvent(commonEventData); @@ -336,12 +338,6 @@ void SaveLaunchInfoFuzz(FuzzedDataProvider &provider) dataShareServiceImpl->SaveLaunchInfo(bundleName, userId, deviceId); } -void OnConnectDoneFuzz(FuzzedDataProvider &provider) -{ - std::shared_ptr dataShareServiceImpl = std::make_shared(); - dataShareServiceImpl->OnConnectDone(); -} - void DataShareStaticOnAppUpdate(FuzzedDataProvider &provider) { DataShareServiceImpl::DataShareStatic dataShareStatic; @@ -357,6 +353,7 @@ void EnableSilentProxyFuzz(FuzzedDataProvider &provider) std::string uri = provider.ConsumeRandomLengthString(); bool enable = provider.ConsumeBool(); dataShareServiceImpl->EnableSilentProxy(uri, enable); + dataShareServiceImpl->OnConnectDone(); } } // namespace OHOS @@ -392,7 +389,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::SubscribePublishedDataFuzz(provider); OHOS::DisablePubSubsFuzz(provider); OHOS::SaveLaunchInfoFuzz(provider); - OHOS::OnConnectDoneFuzz(provider); OHOS::DataShareStaticOnAppUpdate(provider); OHOS::EnableSilentProxyFuzz(provider); return 0; -- Gitee From bfe460ff2f0e67e1cff7b890373d1515df2c96ac Mon Sep 17 00:00:00 2001 From: wangjiaqiang Date: Wed, 20 Aug 2025 16:00:12 +0800 Subject: [PATCH 15/76] fix: remove cfi config Signed-off-by: wangjiaqiang --- services/distributeddataservice/adapter/schema_helper/BUILD.gn | 1 - services/distributeddataservice/adapter/screenlock/BUILD.gn | 1 - 2 files changed, 2 deletions(-) diff --git a/services/distributeddataservice/adapter/schema_helper/BUILD.gn b/services/distributeddataservice/adapter/schema_helper/BUILD.gn index c3516c441..4bdf79b0c 100644 --- a/services/distributeddataservice/adapter/schema_helper/BUILD.gn +++ b/services/distributeddataservice/adapter/schema_helper/BUILD.gn @@ -31,7 +31,6 @@ ohos_source_set("distributeddata_schema_helper") { cflags_cc = [ "-fvisibility=hidden", - "-fstack-protector-strong", ] public_configs = [ ":module_public_config" ] diff --git a/services/distributeddataservice/adapter/screenlock/BUILD.gn b/services/distributeddataservice/adapter/screenlock/BUILD.gn index 766eb3f9e..453ee8212 100644 --- a/services/distributeddataservice/adapter/screenlock/BUILD.gn +++ b/services/distributeddataservice/adapter/screenlock/BUILD.gn @@ -31,7 +31,6 @@ ohos_source_set("distributeddata_screenlock") { cflags_cc = [ "-fvisibility=hidden", - "-fstack-protector-strong", ] public_configs = [ ":module_public_config" ] -- Gitee From c14ae28d36d4cc5661995b52598124f312c8105b Mon Sep 17 00:00:00 2001 From: yangliu Date: Wed, 20 Aug 2025 16:13:43 +0800 Subject: [PATCH 16/76] update Signed-off-by: yangliu --- .../distributeddataservice/app/src/kvstore_data_service.cpp | 2 -- .../distributeddataservice/app/src/security/sensitive.cpp | 4 +++- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index 51af0c61e..d4294c4e5 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -982,8 +982,6 @@ void KvStoreDataService::NotifyAccountEvent(const AccountEventInfo &eventInfo) void KvStoreDataService::InitSecurityAdapter(std::shared_ptr executors) { - auto ret = DATASL_OnStart(); - ZLOGI("datasl on start ret:%d", ret); security_ = std::make_shared(executors); if (security_ == nullptr) { ZLOGE("security is nullptr."); diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index 0cf9aa506..b522ccf42 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -113,9 +113,11 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) ZLOGE("init query params failed! udid:[%{public}s]", Anonymous::Change(udid).c_str()); return DATA_SEC_LEVEL1; } - + auto ret = DATASL_OnStart(); + ZLOGI("datasl on start ret:%{public}d", ret); uint32_t level = DATA_SEC_LEVEL1; int32_t result = DATASL_GetHighestSecLevel(&query, &level); + DATASL_OnStop(); if (result != DEVSL_SUCCESS) { ZLOGE("get highest level failed(%{public}s)! level: %{public}d, error: %d", Anonymous::Change(udid).c_str(), securityLevel, result); -- Gitee From fbee8594580ce8542ca2bc6b4b01268fd546c412 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Mon, 18 Aug 2025 19:31:27 +0800 Subject: [PATCH 17/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/cloud_service_impl.cpp | 13 +--- .../service/cloud/sync_manager.cpp | 62 +++++++++++++++++++ .../service/cloud/sync_manager.h | 21 ++++++- 3 files changed, 85 insertions(+), 11 deletions(-) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 3179ab113..18f294fff 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -796,19 +796,11 @@ int32_t CloudServiceImpl::OnReady(const std::string &device) ZLOGW("current user is not logged in."); return E_NOT_LOGIN; } - std::vector users; - Account::GetInstance()->QueryForegroundUsers(users); - if (users.empty()) { - return SUCCESS; - } + if (!NetworkDelegate::GetInstance()->IsNetworkAvailable()) { return NETWORK_ERROR; } - for (auto user : users) { - DoKvCloudSync(user, "", MODE_ONLINE); - Execute(GenTask(0, user, CloudSyncScene::NETWORK_RECOVERY, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - } + syncManager_.GetNetworkRecoveryManager().OnNetworkConnected(); return SUCCESS; } @@ -825,6 +817,7 @@ int32_t CloudServiceImpl::Offline(const std::string &device) } auto it = users.begin(); syncManager_.StopCloudSync(*it); + syncManager_.GetNetworkRecoveryManager().OnNetworkDisconnected(); return SUCCESS; } diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 39a046674..5c6c4b1a6 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -47,6 +47,7 @@ using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; using Defer = EventCenter::Defer; std::atomic SyncManager::genId_ = 0; constexpr int32_t SYSTEM_USER_ID = 0; +constexpr int32_t TIMEOUT_TIME = 20; // hours static constexpr const char *FT_GET_STORE = "GET_STORE"; static constexpr const char *FT_CALLBACK = "CALLBACK"; SyncManager::SyncInfo::SyncInfo( @@ -364,6 +365,9 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount UpdateStartSyncInfo(cloudSyncInfos); auto code = IsValid(info, cloud); if (code != E_OK) { + if (code == E_NETWORK_ERROR) { + networkRecoveryManager_.RecordSyncApps(info.bundleName_); + } BatchUpdateFinishState(cloudSyncInfos, code); BatchReport(info.user_, traceIds, SyncStage::END, code, "!IsValid"); return; @@ -1084,4 +1088,62 @@ int32_t SyncManager::ConvertValidGeneralCode(int32_t code) { return (code >= E_OK && code < E_BUSY) ? code : E_ERROR; } + +void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() +{ + ZLOGI("network disconnected."); + currentEvent_ = std::make_unique(); + currentEvent_->disconnectTime = std::chrono::system_clock::now(); +} + +void SyncManager::NetworkRecoveryManager::OnNetworkConnected() +{ + ZLOGI("network connected."); + if (!currentEvent_) { + ZLOGE("network connected, but no sync event."); + return; + } + auto now = std::chrono::system_clock::now(); + auto duration = now - currentEvent_->disconnectTime; + auto hours = std::chrono::duration_cast(duration).count(); + bool timeout = (hours > TIMEOUT_TIME); + + std::vector users; + if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { + ZLOGE("no foreground user, skip sync."); + return; + } + auto& syncManager = syncManager_; + for (auto user : users) { + CloudInfo cloud; + cloud.user = user; + if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { + continue; + } + ZLOGI("network connected, sync hours:%{public}ld", hours); + const auto& apps = timeout ? ExtractBundleNames(cloud.apps) : currentEvent_->syncApps; + for (const auto& app : apps) { + ZLOGI("sync app:%{public}s, user:%{public}d", app.c_str(), user); + SyncInfo info(user, app); + syncManager.DoCloudSync(std::move(info)); + } + } + currentEvent_.reset(); +} + +void SyncManager::NetworkRecoveryManager::RecordSyncApps(const std::string &bundleName) +{ + if (currentEvent_) { + ZLOGI("record sync bundleName:%{public}s", bundleName.c_str()); + currentEvent_->syncApps.insert(bundleName); + } +} +std::unordered_set SyncManager::NetworkRecoveryManager::ExtractBundleNames(const std::map apps) +{ + std::unordered_set bundleNames; + for (auto &app : apps) { + bundleNames.insert(app.first); + } + return bundleNames; +} } // namespace OHOS::CloudData \ No newline at end of file diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index a24f0ae66..047da8b90 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -31,6 +31,7 @@ #include "store/general_store.h" #include "store/general_value.h" #include "utils/ref_count.h" +#include namespace OHOS::CloudData { class SyncManager { @@ -104,7 +105,24 @@ public: void OnScreenUnlocked(int32_t user); void CleanCompensateSync(int32_t userId); static std::string GetPath(const StoreMetaData &meta); - + class NetworkRecoveryManager { + public: + NetworkRecoveryManager(SyncManager &syncManager): syncManager_(syncManager) {} + void OnNetworkDisconnected(); + void OnNetworkConnected(); + void RecordSyncApps(const std::string &bundleName); + private: + std::unordered_set ExtractBundleNames(const std::map apps); + struct NetWorkEvent { + std::chrono::system_clock::time_point disconnectTime; + std::unordered_set syncApps; + }; + std::unique_ptr currentEvent_; + SyncManager &syncManager_; + }; + NetworkRecoveryManager& GetNetworkRecoveryManager() { + return networkRecoveryManager_; + } private: using Event = DistributedData::Event; using Task = ExecutorPool::Task; @@ -185,6 +203,7 @@ private: ConcurrentMap> lastSyncInfos_; std::set kvApps_; ConcurrentMap>> compensateSyncInfos_; + NetworkRecoveryManager networkRecoveryManager_{*this}; }; } // namespace OHOS::CloudData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_SYNC_MANAGER_H \ No newline at end of file -- Gitee From 3f4618c5ab448302e9c30de9b1d504194897e6b3 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Thu, 21 Aug 2025 14:32:28 +0800 Subject: [PATCH 18/76] fix: codecheck Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 9 +++++---- .../service/cloud/sync_manager.h | 14 ++++++++++---- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 5c6c4b1a6..7c147135f 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -1113,7 +1113,7 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() ZLOGE("no foreground user, skip sync."); return; } - auto& syncManager = syncManager_; + auto &syncManager = syncManager_; for (auto user : users) { CloudInfo cloud; cloud.user = user; @@ -1121,8 +1121,8 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() continue; } ZLOGI("network connected, sync hours:%{public}ld", hours); - const auto& apps = timeout ? ExtractBundleNames(cloud.apps) : currentEvent_->syncApps; - for (const auto& app : apps) { + const auto &apps = timeout ? ExtractBundleNames(cloud.apps) : currentEvent_->syncApps; + for (const auto &app : apps) { ZLOGI("sync app:%{public}s, user:%{public}d", app.c_str(), user); SyncInfo info(user, app); syncManager.DoCloudSync(std::move(info)); @@ -1138,7 +1138,8 @@ void SyncManager::NetworkRecoveryManager::RecordSyncApps(const std::string &bund currentEvent_->syncApps.insert(bundleName); } } -std::unordered_set SyncManager::NetworkRecoveryManager::ExtractBundleNames(const std::map apps) +std::unordered_set SyncManager::NetworkRecoveryManager::ExtractBundleNames( + const std::map apps) { std::unordered_set bundleNames; for (auto &app : apps) { diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index 047da8b90..0a56cfd2a 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -107,12 +107,16 @@ public: static std::string GetPath(const StoreMetaData &meta); class NetworkRecoveryManager { public: - NetworkRecoveryManager(SyncManager &syncManager): syncManager_(syncManager) {} + NetworkRecoveryManager(SyncManager &syncManager) : syncManager_(syncManager) + { + } void OnNetworkDisconnected(); void OnNetworkConnected(); void RecordSyncApps(const std::string &bundleName); + private: - std::unordered_set ExtractBundleNames(const std::map apps); + std::unordered_set ExtractBundleNames( + const std::map apps); struct NetWorkEvent { std::chrono::system_clock::time_point disconnectTime; std::unordered_set syncApps; @@ -120,9 +124,11 @@ public: std::unique_ptr currentEvent_; SyncManager &syncManager_; }; - NetworkRecoveryManager& GetNetworkRecoveryManager() { + NetworkRecoveryManager &GetNetworkRecoveryManager() + { return networkRecoveryManager_; } + private: using Event = DistributedData::Event; using Task = ExecutorPool::Task; @@ -203,7 +209,7 @@ private: ConcurrentMap> lastSyncInfos_; std::set kvApps_; ConcurrentMap>> compensateSyncInfos_; - NetworkRecoveryManager networkRecoveryManager_{*this}; + NetworkRecoveryManager networkRecoveryManager_{ *this }; }; } // namespace OHOS::CloudData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_SYNC_MANAGER_H \ No newline at end of file -- Gitee From 96e0f539a40ec67672e4f6c920455eec972e218f Mon Sep 17 00:00:00 2001 From: yangliu Date: Thu, 21 Aug 2025 16:48:20 +0800 Subject: [PATCH 19/76] update Signed-off-by: yangliu --- .../distributeddataservice/app/src/security/sensitive.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index b522ccf42..0b097a05a 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -114,7 +114,10 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) return DATA_SEC_LEVEL1; } auto ret = DATASL_OnStart(); - ZLOGI("datasl on start ret:%{public}d", ret); + if (ret != DEVSL_SUCCESS) { + ZLOGI("datasl on start failed, ret:%{public}d", ret); + return DATA_SEC_LEVEL1; + } uint32_t level = DATA_SEC_LEVEL1; int32_t result = DATASL_GetHighestSecLevel(&query, &level); DATASL_OnStop(); -- Gitee From bb97ed7363e880b6260686362a0521ca825fd724 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Thu, 21 Aug 2025 20:12:29 +0800 Subject: [PATCH 20/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/cloud_service_impl.cpp | 10 +++ .../service/cloud/sync_manager.cpp | 76 ++++++++++--------- .../service/cloud/sync_manager.h | 10 +-- 3 files changed, 57 insertions(+), 39 deletions(-) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 18f294fff..903657cc7 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -796,10 +796,20 @@ int32_t CloudServiceImpl::OnReady(const std::string &device) ZLOGW("current user is not logged in."); return E_NOT_LOGIN; } + std::vector users; + Account::GetInstance()->QueryForegroundUsers(users); + if (users.empty()) { + return SUCCESS; + } if (!NetworkDelegate::GetInstance()->IsNetworkAvailable()) { return NETWORK_ERROR; } + + for (auto user : users) { + Execute(GenTask(0, user, CloudSyncScene::NETWORK_RECOVERY, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + } syncManager_.GetNetworkRecoveryManager().OnNetworkConnected(); return SUCCESS; } diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 7c147135f..c71d80343 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -365,8 +365,8 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount UpdateStartSyncInfo(cloudSyncInfos); auto code = IsValid(info, cloud); if (code != E_OK) { - if (code == E_NETWORK_ERROR) { - networkRecoveryManager_.RecordSyncApps(info.bundleName_); + if (code == E_NETWORK_ERROR && retry) { + networkRecoveryManager_.RecordSyncApps(info.user_, info.bundleName_); } BatchUpdateFinishState(cloudSyncInfos, code); BatchReport(info.user_, traceIds, SyncStage::END, code, "!IsValid"); @@ -1098,53 +1098,61 @@ void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() void SyncManager::NetworkRecoveryManager::OnNetworkConnected() { - ZLOGI("network connected."); + ZLOGI("network connected start."); if (!currentEvent_) { - ZLOGE("network connected, but no sync event."); + ZLOGE("network connected, but currentEvent_ is not initialized."); return; } auto now = std::chrono::system_clock::now(); auto duration = now - currentEvent_->disconnectTime; auto hours = std::chrono::duration_cast(duration).count(); bool timeout = (hours > TIMEOUT_TIME); - - std::vector users; - if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { - ZLOGE("no foreground user, skip sync."); - return; - } - auto &syncManager = syncManager_; - for (auto user : users) { - CloudInfo cloud; - cloud.user = user; - if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { - continue; - } - ZLOGI("network connected, sync hours:%{public}ld", hours); - const auto &apps = timeout ? ExtractBundleNames(cloud.apps) : currentEvent_->syncApps; - for (const auto &app : apps) { - ZLOGI("sync app:%{public}s, user:%{public}d", app.c_str(), user); - SyncInfo info(user, app); - syncManager.DoCloudSync(std::move(info)); - } - } + CompensateSync(timeout); currentEvent_.reset(); + ZLOGI("network connected end, sync hours:%{public}ld", hours); } -void SyncManager::NetworkRecoveryManager::RecordSyncApps(const std::string &bundleName) +void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, const std::string &bundleName) { if (currentEvent_) { - ZLOGI("record sync bundleName:%{public}s", bundleName.c_str()); - currentEvent_->syncApps.insert(bundleName); + ZLOGI("record sync user:%{public}d, bundleName:%{public}s", user, bundleName.c_str()); + std::lock_guard lock(syncAppsMutex_); + currentEvent_->syncApps[user].insert(bundleName); } } -std::unordered_set SyncManager::NetworkRecoveryManager::ExtractBundleNames( - const std::map apps) +void SyncManager::NetworkRecoveryManager::CompensateSync(bool timeout) { - std::unordered_set bundleNames; - for (auto &app : apps) { - bundleNames.insert(app.first); + std::vector users; + if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { + ZLOGE("no foreground user, skip sync."); + return; + } + if (timeout) { + for (auto user : users) { + CloudInfo cloud; + cloud.user = user; + if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { + ZLOGE("load cloud info fail, user:%{public}d", user); + continue; + } + for (const auto &app : cloud.apps) { + ZLOGI("sync start bundleName:%{public}s, user:%{public}d", app.second.bundleName.c_str(), user); + syncManager_.DoCloudSync(SyncInfo(user, app.second.bundleName)); + } + } + } else { + std::lock_guard lock(syncAppsMutex_); + for (int32_t user : users) { + auto item = currentEvent_->syncApps.find(user); + if (item == currentEvent_->syncApps.end()) { + continue; + } + const auto &apps = item->second; + for (const auto &app : apps) { + ZLOGI("sync start bundleName:%{public}s, user:%{public}d", app.c_str(), user); + syncManager_.DoCloudSync(SyncInfo(user, app)); + } + } } - return bundleNames; } } // namespace OHOS::CloudData \ No newline at end of file diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index 0a56cfd2a..fff9f0bf9 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -107,20 +107,20 @@ public: static std::string GetPath(const StoreMetaData &meta); class NetworkRecoveryManager { public: - NetworkRecoveryManager(SyncManager &syncManager) : syncManager_(syncManager) + explicit NetworkRecoveryManager(SyncManager &syncManager) : syncManager_(syncManager) { } void OnNetworkDisconnected(); void OnNetworkConnected(); - void RecordSyncApps(const std::string &bundleName); + void RecordSyncApps(const int32_t user, const std::string &bundleName); private: - std::unordered_set ExtractBundleNames( - const std::map apps); + void CompensateSync(bool timeout); struct NetWorkEvent { std::chrono::system_clock::time_point disconnectTime; - std::unordered_set syncApps; + std::map> syncApps; }; + std::mutex syncAppsMutex_; std::unique_ptr currentEvent_; SyncManager &syncManager_; }; -- Gitee From 9dd4498a7abff33bc95803bfa2d542aa403e633d Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Thu, 21 Aug 2025 20:15:04 +0800 Subject: [PATCH 21/76] fix: Signed-off-by: weishaoxiong --- .../distributeddataservice/service/cloud/cloud_service_impl.cpp | 2 -- services/distributeddataservice/service/cloud/sync_manager.cpp | 1 + 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 903657cc7..4542e32be 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -801,11 +801,9 @@ int32_t CloudServiceImpl::OnReady(const std::string &device) if (users.empty()) { return SUCCESS; } - if (!NetworkDelegate::GetInstance()->IsNetworkAvailable()) { return NETWORK_ERROR; } - for (auto user : users) { Execute(GenTask(0, user, CloudSyncScene::NETWORK_RECOVERY, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index c71d80343..5054bb284 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -1120,6 +1120,7 @@ void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, con currentEvent_->syncApps[user].insert(bundleName); } } + void SyncManager::NetworkRecoveryManager::CompensateSync(bool timeout) { std::vector users; -- Gitee From cdb3f3b13077ca77a1190a8608d5c9b732ac71df Mon Sep 17 00:00:00 2001 From: zph Date: Tue, 19 Aug 2025 17:41:47 +0800 Subject: [PATCH 22/76] update Signed-off-by: zph --- .../service/test/udmf_service_impl_test.cpp | 153 ++++++++++++++++++ .../service/udmf/udmf_service_impl.cpp | 68 +++++--- .../service/udmf/udmf_service_impl.h | 11 +- 3 files changed, 201 insertions(+), 31 deletions(-) diff --git a/services/distributeddataservice/service/test/udmf_service_impl_test.cpp b/services/distributeddataservice/service/test/udmf_service_impl_test.cpp index 9a32e1587..d5ae9fab1 100644 --- a/services/distributeddataservice/service/test/udmf_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/udmf_service_impl_test.cpp @@ -676,5 +676,158 @@ HWTEST_F(UdmfServiceImplTest, VerifyDataAccessPermission002, TestSize.Level1) EXPECT_EQ(runtime->privileges[0].tokenId, query.tokenId); EXPECT_EQ(result, OHOS::UDMF::E_OK); } + +/** + * @tc.name: HandleDelayLoad001 + * @tc.desc: Returns true when data not arrives + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, HandleDelayLoad001, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = 123; + + UnifiedData result; + int32_t res = UDMF::E_OK; + + UdmfServiceImpl service; + service.dataLoadCallback_.Insert(query.key, nullptr); + + using CacheData = BlockData, std::chrono::milliseconds>; + UdmfServiceImpl::BlockDelayData data; + data.tokenId = query.tokenId; + data.blockData = std::make_shared(100); + service.blockDelayDataCache_.Insert(query.key, data); + + bool handled = service.HandleDelayLoad(query, result, res); + + service.dataLoadCallback_.Erase(query.key); + service.blockDelayDataCache_.Erase(query.key); + + EXPECT_TRUE(handled); + EXPECT_EQ(res, UDMF::E_NOT_FOUND); +} + +/** + * @tc.name: HandleDelayLoad002 + * @tc.desc: Returns false when not exist + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, HandleDelayLoad002, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = 123; + + UnifiedData result; + int32_t res = UDMF::E_OK; + + UdmfServiceImpl service; + bool handled = service.HandleDelayLoad(query, result, res); + + EXPECT_FALSE(handled); +} + +/** + * @tc.name: HandleDelayLoad003 + * @tc.desc: Returns true when data arrives + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, HandleDelayLoad003, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = 123; + + UnifiedData result; + int32_t res = UDMF::E_OK; + + UnifiedData insertedData; + insertedData.AddRecord(std::make_shared()); + + UdmfServiceImpl service; + service.dataLoadCallback_.Insert(query.key, nullptr); + + using CacheData = BlockData, std::chrono::milliseconds>; + UdmfServiceImpl::BlockDelayData data; + data.tokenId = query.tokenId; + data.blockData = std::make_shared(100); + service.blockDelayDataCache_.Insert(query.key, data); + + data.blockData->SetValue(insertedData); + bool handled = service.HandleDelayLoad(query, result, res); + + EXPECT_TRUE(handled); + EXPECT_EQ(res, UDMF::E_OK); +} + +/** + * @tc.name: PushDelayData002 + * @tc.desc: DelayData callback and block cache not exist + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, PushDelayData002, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = 123; + UnifiedData insertedData; + insertedData.AddRecord(std::make_shared()); + + UdmfServiceImpl service; + auto status = service.PushDelayData(query.key, insertedData); + EXPECT_EQ(status, UDMF::E_ERROR); +} + +/** + * @tc.name: PushDelayData003 + * @tc.desc: No permission + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, PushDelayData003, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = 123; + + using CacheData = BlockData, std::chrono::milliseconds>; + UdmfServiceImpl::BlockDelayData data; + data.tokenId = query.tokenId; + data.blockData = std::make_shared(100); + UdmfServiceImpl service; + service.blockDelayDataCache_.Insert(query.key, data); + + UnifiedData insertedData; + auto status = service.PushDelayData(query.key, insertedData); + EXPECT_EQ(status, UDMF::E_NO_PERMISSION); +} + +/** + * @tc.name: PushDelayData004 + * @tc.desc: PushDelayData success + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, PushDelayData004, TestSize.Level1) +{ + QueryOption query; + query.key = "k1"; + query.tokenId = IPCSkeleton::GetSelfTokenID(); + + using CacheData = BlockData, std::chrono::milliseconds>; + UdmfServiceImpl::BlockDelayData data; + data.tokenId = query.tokenId; + data.blockData = std::make_shared(100); + UdmfServiceImpl service; + service.blockDelayDataCache_.Insert(query.key, data); + + Privilege privilege; + privilege.tokenId = query.tokenId; + service.privilegeCache_[query.key] = privilege; + + UnifiedData insertedData; + auto status = service.PushDelayData(query.key, insertedData); + EXPECT_EQ(status, UDMF::E_OK); +} }; // namespace DistributedDataTest }; // namespace OHOS::Test diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 631d033c8..0611b796f 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -67,7 +67,7 @@ constexpr const char *DEVICE_PHONE_TAG = "phone"; constexpr const char *DEVICE_DEFAULT_TAG = "default"; constexpr const char *HAP_LIST[] = {"com.ohos.pasteboarddialog"}; constexpr uint32_t FOUNDATION_UID = 5523; -constexpr uint32_t WAIT_TIME = 1; +constexpr uint32_t WAIT_TIME = 800; __attribute__((used)) UdmfServiceImpl::Factory UdmfServiceImpl::factory_; UdmfServiceImpl::Factory::Factory() { @@ -176,23 +176,13 @@ int32_t UdmfServiceImpl::GetData(const QueryOption &query, UnifiedData &unifiedD if (!PreProcessUtils::GetHapBundleNameByToken(query.tokenId, bundleName)) { msg.appId = "unknown"; Reporter::GetInstance()->GetBehaviourReporter()->UDMFReport(msg); + ZLOGE("Failed to get bundle name by token, token:%{public}d", query.tokenId); return E_ERROR; } - msg.appId = bundleName; - bool isDelayLoad = dataLoadCallback_.ComputeIfPresent(key, [&unifiedData](auto &key, BlockDelayData &val) { - blockDelayDataCache_.ComputeIfAbsent(query.key, [&query](auto &key) { - auto blockData = std::make_shared>>(WAIT_TIME); - return BlockDelayData { blockData, query.tokenId }; - }); - auto data = val.blockData->GetValue(); - if (data != std::nullopt) { - unifiedData = *data; - return false; - } - return true; - }); - if (!isDelayLoad) { + + bool handledByDelay = HandleDelayLoad(query, unifiedData, res); + if (!handledByDelay) { res = RetrieveData(query, unifiedData); } auto errFind = ERROR_MAP.find(res); @@ -205,9 +195,36 @@ int32_t UdmfServiceImpl::GetData(const QueryOption &query, UnifiedData &unifiedD msg.dataType = types; msg.dataSize = unifiedData.GetSize(); Reporter::GetInstance()->GetBehaviourReporter()->UDMFReport(msg); + if (res != E_OK) { + ZLOGE("GetData failed, res:%{public}d, key:%{public}s", res, query.key.c_str()); + } return res; } +bool UdmfServiceImpl::HandleDelayLoad(const QueryOption &query, UnifiedData &unifiedData, int32_t &res) +{ + return dataLoadCallback_.ComputeIfPresent(query.key, [&](const auto &key, auto &callback) { + std::shared_ptr, std::chrono::milliseconds>> blockData; + auto [found, cache] = blockDelayDataCache_.Find(key); + if (!found) { + blockData = std::make_shared, std::chrono::milliseconds>>(WAIT_TIME); + blockDelayDataCache_.Insert(key, BlockDelayData{query.tokenId, blockData}); + callback->HandleDelayObserver(key, DataLoadInfo()); + } else { + blockData = cache.blockData; + } + ZLOGI("Start waiting for data, key:%{public}s", key.c_str()); + auto dataOpt = blockData->GetValue(); + if (dataOpt.has_value()) { + unifiedData = *dataOpt; + blockDelayDataCache_.Erase(key); + return false; + } + res = E_NOT_FOUND; + return true; + }); +} + bool UdmfServiceImpl::CheckDragParams(UnifiedKey &key, const QueryOption &query) { if (!key.IsValid()) { @@ -262,11 +279,9 @@ int32_t UdmfServiceImpl::RetrieveData(const QueryOption &query, UnifiedData &uni return E_NO_PERMISSION; } } - if (!IsReadAndKeep(runtime->privileges, query)) { - if (LifeCycleManager::GetInstance().OnGot(key) != E_OK) { - ZLOGE("Remove data failed:%{public}s", key.intention.c_str()); - return E_DB_ERROR; - } + if (!IsReadAndKeep(runtime->privileges, query) && LifeCycleManager::GetInstance().OnGot(key) != E_OK) { + ZLOGE("Remove data failed:%{public}s", key.intention.c_str()); + return E_DB_ERROR; } { @@ -1214,8 +1229,10 @@ int32_t UdmfServiceImpl::SetDelayInfo(const DataLoadInfo &dataLoadInfo, sptrSetValue(unifiedData); + blockIt.second.blockData->SetValue(unifiedData); return E_OK; } - return HandleDelayDataCallback(delayDataCallback_.Find(key).second, unifiedData, key); + return HandleDelayDataCallback(delayIt.second, unifiedData, key); } int32_t UdmfServiceImpl::HandleDelayDataCallback(DelayGetDataInfo &delayGetDataInfo, UnifiedData &unifiedData, diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.h b/services/distributeddataservice/service/udmf/udmf_service_impl.h index a738cc04d..beef4dda4 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.h +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.h @@ -16,13 +16,13 @@ #ifndef UDMF_SERVICE_IMPL_H #define UDMF_SERVICE_IMPL_H -#include "store_cache.h" -#include "udmf_service_stub.h" +#include "block_data.h" +#include "checker_manager.h" #include "kv_store_delegate_manager.h" #include "metadata/store_meta_data.h" -#include "checker_manager.h" +#include "store_cache.h" #include "udmf_notifier_proxy.h" -#include "block_data.h" +#include "udmf_service_stub.h" namespace OHOS { namespace UDMF { /* @@ -93,6 +93,7 @@ private: std::vector ProcessResult(const std::map &results); DistributedData::StoreMetaData BuildMeta(const std::string &storeId, int userId); int32_t VerifyUpdatePermission(const QueryOption &query, UnifiedData &unifiedData, std::string &bundleName); + bool HandleDelayLoad(const QueryOption &query, UnifiedData &unifiedData, int32_t &res); class Factory { public: @@ -114,7 +115,7 @@ private: struct BlockDelayData { uint32_t tokenId {0}; - std::shared_ptr>> blockData; + std::shared_ptr, std::chrono::milliseconds>> blockData; }; ConcurrentMap blockDelayDataCache_ {}; }; -- Gitee From 30d9fc9663a238a666b00d6bc9154437bd093b48 Mon Sep 17 00:00:00 2001 From: zhai-peizhe Date: Fri, 22 Aug 2025 14:46:57 +0800 Subject: [PATCH 23/76] =?UTF-8?q?=E4=BF=AE=E6=94=B9private=E6=89=93?= =?UTF-8?q?=E5=8D=B0=E5=B9=B6=E6=8C=89=E9=9C=80=E5=AF=B9=E6=89=93=E5=8D=B0?= =?UTF-8?q?=E5=86=85=E5=AE=B9=E8=BF=9B=E8=A1=8C=E5=8C=BF=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhai-peizhe Change-Id: I34538ef5d388e4a2eae486fdc2fc8c899cfb60d6 --- .../service/data_share/common/kv_delegate.cpp | 2 +- .../service/data_share/common/proxy_data_manager.cpp | 2 +- .../service/data_share/common/rdb_delegate.cpp | 7 ++++--- .../service/data_share/common/scheduler_manager.cpp | 4 ++-- .../service/data_share/data/template_data.cpp | 6 ++++-- .../service/data_share/data_share_service_impl.cpp | 12 ++++++------ 6 files changed, 18 insertions(+), 15 deletions(-) diff --git a/services/distributeddataservice/service/data_share/common/kv_delegate.cpp b/services/distributeddataservice/service/data_share/common/kv_delegate.cpp index 1c2375d43..d9f4d194c 100644 --- a/services/distributeddataservice/service/data_share/common/kv_delegate.cpp +++ b/services/distributeddataservice/service/data_share/common/kv_delegate.cpp @@ -282,7 +282,7 @@ std::pair KvDelegate::Upsert(const std::string &collectionName int version = -1; if (GetVersion(collectionName, id, version)) { if (value.GetVersion() <= version) { - ZLOGE("GetVersion failed,%{public}s id %{private}s %{public}d %{public}d", collectionName.c_str(), + ZLOGE("GetVersion failed,%{public}s id %{public}s %{public}d %{public}d", collectionName.c_str(), id.c_str(), value.GetVersion(), version); return std::make_pair(E_VERSION_NOT_NEWER, 0); } diff --git a/services/distributeddataservice/service/data_share/common/proxy_data_manager.cpp b/services/distributeddataservice/service/data_share/common/proxy_data_manager.cpp index 18a7b5363..8a9988e0c 100644 --- a/services/distributeddataservice/service/data_share/common/proxy_data_manager.cpp +++ b/services/distributeddataservice/service/data_share/common/proxy_data_manager.cpp @@ -337,7 +337,7 @@ int32_t PublishedProxyData::Delete(const std::string &uri, const BundleInfo &cal ProxyDataNode oldData; if (!ProxyDataNode::Unmarshall(queryResult, oldData)) { - ZLOGE("Unmarshall failed, %{private}s", queryResult.c_str()); + ZLOGE("Unmarshall failed, %{public}s", StringUtils::GeneralAnonymous(queryResult).c_str()); return INNER_ERROR; } if (callerBundleInfo.tokenId != oldData.tokenId) { diff --git a/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp b/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp index 940f599c4..2edad984d 100644 --- a/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp +++ b/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp @@ -31,6 +31,7 @@ #include "scheduler_manager.h" #include "string_wrapper.h" #include "utils/anonymous.h" +#include "utils.h" #include "want_params.h" #include "db_delegate.h" #include "log_debug.h" @@ -298,7 +299,7 @@ std::string RdbDelegate::Query(const std::string &sql, const std::vectorQueryByStep(sql, selectionArgs); if (resultSet == nullptr) { - ZLOGE("Query failed %{private}s", sql.c_str()); + ZLOGE("Query failed %{public}s", StringUtils::GeneralAnonymous(sql).c_str()); return ""; } int rowCount; @@ -318,7 +319,7 @@ std::shared_ptr RdbDelegate::QuerySql(const std::string &s } auto resultSet = store_->QuerySql(sql); if (resultSet == nullptr) { - ZLOGE("Query failed %{private}s", sql.c_str()); + ZLOGE("Query failed %{public}s", StringUtils::GeneralAnonymous(sql).c_str()); return resultSet; } int rowCount; @@ -375,4 +376,4 @@ bool RdbDelegate::IsLimit(int count, int32_t callingPid, uint32_t callingTokenId HiViewFaultAdapter::ReportDataFault(faultInfo); return true; } -} // namespace OHOS::DataShare \ No newline at end of file +} // namespace OHOS::DataShare diff --git a/services/distributeddataservice/service/data_share/common/scheduler_manager.cpp b/services/distributeddataservice/service/data_share/common/scheduler_manager.cpp index fa7ec6a96..d8a87a67d 100644 --- a/services/distributeddataservice/service/data_share/common/scheduler_manager.cpp +++ b/services/distributeddataservice/service/data_share/common/scheduler_manager.cpp @@ -209,14 +209,14 @@ void SchedulerManager::SetTimer( duration, key.subscriberId, key.bundleName.c_str()); auto it = timerCache_.find(key); if (it != timerCache_.end()) { - ZLOGD_MACRO("has current taskId: %{private}s, subscriberId is %{public}" PRId64 ", bundleName is %{public}s", + ZLOGD_MACRO("has current taskId: %{public}s, subscriberId is %{public}" PRId64 ", bundleName is %{public}s", URIUtils::Anonymous(key.uri).c_str(), key.subscriberId, key.bundleName.c_str()); auto timerId = it->second; ResetTimerTask(timerId, reminderTime); return; } auto callback = [key, metaData, userId, this]() { - ZLOGI("schedule notify start, uri is %{private}s, subscriberId is %{public}" PRId64 ", bundleName is " + ZLOGI("schedule notify start, uri is %{public}s, subscriberId is %{public}" PRId64 ", bundleName is " "%{public}s", URIUtils::Anonymous(key.uri).c_str(), key.subscriberId, key.bundleName.c_str()); int64_t timerId = EraseTimerTaskId(key); diff --git a/services/distributeddataservice/service/data_share/data/template_data.cpp b/services/distributeddataservice/service/data_share/data/template_data.cpp index 79219aede..af7bbb26e 100644 --- a/services/distributeddataservice/service/data_share/data/template_data.cpp +++ b/services/distributeddataservice/service/data_share/data/template_data.cpp @@ -15,6 +15,8 @@ #define LOG_TAG "TemplateData" #include "template_data.h" #include "log_print.h" +#include "utils.h" + namespace OHOS::DataShare { bool TemplateNode::Marshal(DistributedData::Serializable::json &node) const { @@ -121,7 +123,7 @@ int32_t TemplateData::Query(const std::string &filter, Template &aTemplate) } TemplateRootNode data; if (!DistributedData::Serializable::Unmarshall(queryResult, data)) { - ZLOGE("Unmarshall failed, %{private}s", queryResult.c_str()); + ZLOGE("Unmarshall failed, %{public}s", StringUtils::GeneralAnonymous(queryResult).c_str()); return E_ERROR; } aTemplate = data.ToTemplate(); @@ -207,4 +209,4 @@ bool PredicatesNode::Unmarshal(const DistributedData::Serializable::json &node) ret = ret && GetValue(node, GET_NAME(selectSql), selectSql); return ret; } -} // namespace OHOS::DataShare \ No newline at end of file +} // namespace OHOS::DataShare diff --git a/services/distributeddataservice/service/data_share/data_share_service_impl.cpp b/services/distributeddataservice/service/data_share/data_share_service_impl.cpp index 0b3e7c81b..5e0e589ad 100644 --- a/services/distributeddataservice/service/data_share/data_share_service_impl.cpp +++ b/services/distributeddataservice/service/data_share/data_share_service_impl.cpp @@ -262,9 +262,9 @@ int32_t DataShareServiceImpl::AddTemplate(const std::string &uri, const int64_t ZLOGE("get bundleName error, %{public}s", URIUtils::Anonymous(uri).c_str()); return ERROR; } - ZLOGI("Add template, uri %{private}s, subscriberId %{public}" PRIi64 ", bundleName %{public}s," + ZLOGI("Add template, uri %{public}s, subscriberId %{public}" PRIi64 ", bundleName %{public}s," "predicates size %{public}zu.", - uri.c_str(), subscriberId, tpltId.bundleName_.c_str(), tplt.predicates_.size()); + URIUtils::Anonymous(uri).c_str(), subscriberId, tpltId.bundleName_.c_str(), tplt.predicates_.size()); return templateStrategy_.Execute(context, [&uri, &tpltId, &tplt, &context]() -> int32_t { auto result = TemplateManager::GetInstance().Add( Key(uri, tpltId.subscriberId_, tpltId.bundleName_), context->visitedUserId, tplt); @@ -282,7 +282,7 @@ int32_t DataShareServiceImpl::DelTemplate(const std::string &uri, const int64_t ZLOGE("get bundleName error, %{public}s", URIUtils::Anonymous(uri).c_str()); return ERROR; } - ZLOGI("Delete template, uri %{private}s, subscriberId %{public}" PRIi64 ", bundleName %{public}s.", + ZLOGI("Delete template, uri %{public}s, subscriberId %{public}" PRIi64 ", bundleName %{public}s.", URIUtils::Anonymous(uri).c_str(), subscriberId, tpltId.bundleName_.c_str()); return templateStrategy_.Execute(context, [&uri, &tpltId, &context]() -> int32_t { return TemplateManager::GetInstance().Delete( @@ -871,15 +871,15 @@ int32_t DataShareServiceImpl::OnAppUpdate(const std::string &bundleName, int32_t void DataShareServiceImpl::NotifyObserver(const std::string &uri) { auto anonymous = URIUtils::Anonymous(uri); - ZLOGD_MACRO("%{private}s try notified", anonymous.c_str()); + ZLOGD_MACRO("%{public}s try notified", anonymous.c_str()); auto context = std::make_shared(uri); if (!GetCallerBundleName(context->callerBundleName)) { - ZLOGE("get bundleName error, %{private}s", anonymous.c_str()); + ZLOGE("get bundleName error, %{public}s", anonymous.c_str()); return; } auto ret = rdbNotifyStrategy_.Execute(context); if (ret) { - ZLOGI("%{private}s start notified", anonymous.c_str()); + ZLOGI("%{public}s start notified", anonymous.c_str()); RdbSubscriberManager::GetInstance().Emit(uri, context); } } -- Gitee From 92022c25a348ba020965e46d6aeb7d8b00bc80f3 Mon Sep 17 00:00:00 2001 From: gecheng Date: Fri, 22 Aug 2025 14:55:40 +0800 Subject: [PATCH 24/76] =?UTF-8?q?fuzz=E7=94=A8=E4=BE=8B=E9=97=AE=E9=A2=98?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn | 2 ++ .../fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp | 2 ++ 2 files changed, 4 insertions(+) diff --git a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn index 1be915e1e..26a132ffe 100644 --- a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn @@ -20,6 +20,7 @@ ohos_fuzztest("SyncStrategiesFuzzTest") { module_out_path = "datamgr_service/datamgr_service" include_dirs = [ + "${data_service_path}/adapter/network", "${data_service_path}/framework/include", "${data_service_path}/service/cloud", "${data_service_path}/service/common", @@ -52,6 +53,7 @@ ohos_fuzztest("SyncStrategiesFuzzTest") { "access_token:libtoken_setproc", "access_token:libtokenid_sdk", "c_utils:utils", + "device_manager:devicemanagersdk", "hilog:libhilog", "json:nlohmann_json_static", "kv_store:datamgr_common", diff --git a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp index 2cf4591d3..0b12c1577 100644 --- a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp @@ -14,6 +14,7 @@ */ #include +#include "src/network_delegate_normal_impl.h" #include "syncstrategies_fuzzer.h" #include "sync_strategies/network_sync_strategy.h" @@ -25,6 +26,7 @@ void SyncStrategiesFuzz001(FuzzedDataProvider &provider) { int32_t user = provider.ConsumeIntegral(); std::string bundleName = provider.ConsumeRandomLengthString(100); + NetworkDelegateNormalImpl::Init(); NetworkSyncStrategy strategy; StoreInfo storeInfo; storeInfo.user = user; -- Gitee From 5cd2e768d904faf09192e733d6b64cc1dcfd4841 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Fri, 22 Aug 2025 15:30:53 +0800 Subject: [PATCH 25/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 70 +++++++++++-------- .../service/cloud/sync_manager.h | 5 +- 2 files changed, 42 insertions(+), 33 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 5054bb284..003dad5fe 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -365,7 +365,7 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount UpdateStartSyncInfo(cloudSyncInfos); auto code = IsValid(info, cloud); if (code != E_OK) { - if (code == E_NETWORK_ERROR && retry) { + if (code == E_NETWORK_ERROR) { networkRecoveryManager_.RecordSyncApps(info.user_, info.bundleName_); } BatchUpdateFinishState(cloudSyncInfos, code); @@ -1107,9 +1107,20 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() auto duration = now - currentEvent_->disconnectTime; auto hours = std::chrono::duration_cast(duration).count(); bool timeout = (hours > TIMEOUT_TIME); - CompensateSync(timeout); + std::vector users; + if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { + ZLOGE("no foreground user, skip sync."); + return; + } + for (auto user : users) { + auto syncApps = GetAppList(user, timeout); + for (const auto &bundleName : syncApps) { + ZLOGI("sync start bundleName:%{public}s, user:%{public}d", bundleName.c_str(), user); + syncManager_.DoCloudSync(SyncInfo(user, bundleName, "", {}, MODE_ONLINE)); + } + } currentEvent_.reset(); - ZLOGI("network connected end, sync hours:%{public}ld", hours); + ZLOGI("network connected end, network disconnect duration :%{public}ld hours", hours); } void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, const std::string &bundleName) @@ -1117,43 +1128,42 @@ void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, con if (currentEvent_) { ZLOGI("record sync user:%{public}d, bundleName:%{public}s", user, bundleName.c_str()); std::lock_guard lock(syncAppsMutex_); - currentEvent_->syncApps[user].insert(bundleName); + auto &syncApps = currentEvent_->syncApps[user]; + if (std::find(syncApps.begin(), syncApps.end(), bundleName) == syncApps.end()) { + syncApps.push_back(bundleName); + } } } -void SyncManager::NetworkRecoveryManager::CompensateSync(bool timeout) +std::vector SyncManager::NetworkRecoveryManager::GetAppList(const int32_t user, bool timeout) { - std::vector users; - if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { - ZLOGE("no foreground user, skip sync."); - return; - } + std::vector appList; if (timeout) { - for (auto user : users) { - CloudInfo cloud; - cloud.user = user; - if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { - ZLOGE("load cloud info fail, user:%{public}d", user); - continue; - } - for (const auto &app : cloud.apps) { - ZLOGI("sync start bundleName:%{public}s, user:%{public}d", app.second.bundleName.c_str(), user); - syncManager_.DoCloudSync(SyncInfo(user, app.second.bundleName)); + CloudInfo cloud; + cloud.user = user; + if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { + ZLOGE("load cloud info fail, user:%{public}d", user); + return appList; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + for (const auto &store : stores) { + appList.push_back(store.bundleName); + } + for (const auto &app : cloud.apps) { + if (std::find(appList.begin(), appList.end(), app.second.bundleName) == appList.end()) { + appList.push_back(app.second.bundleName); } } } else { std::lock_guard lock(syncAppsMutex_); - for (int32_t user : users) { - auto item = currentEvent_->syncApps.find(user); - if (item == currentEvent_->syncApps.end()) { - continue; - } - const auto &apps = item->second; - for (const auto &app : apps) { - ZLOGI("sync start bundleName:%{public}s, user:%{public}d", app.c_str(), user); - syncManager_.DoCloudSync(SyncInfo(user, app)); - } + auto item = currentEvent_->syncApps.find(user); + if (item == currentEvent_->syncApps.end()) { + return appList; } + appList = item->second; } + return appList; } } // namespace OHOS::CloudData \ No newline at end of file diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index fff9f0bf9..ef2cc1b6e 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -31,7 +31,6 @@ #include "store/general_store.h" #include "store/general_value.h" #include "utils/ref_count.h" -#include namespace OHOS::CloudData { class SyncManager { @@ -115,10 +114,10 @@ public: void RecordSyncApps(const int32_t user, const std::string &bundleName); private: - void CompensateSync(bool timeout); + std::vector GetAppList(const int32_t user, bool timeout); struct NetWorkEvent { std::chrono::system_clock::time_point disconnectTime; - std::map> syncApps; + std::map> syncApps; }; std::mutex syncAppsMutex_; std::unique_ptr currentEvent_; -- Gitee From c5b5cfd85d8538ec6846fe95336682fc7af8dfa9 Mon Sep 17 00:00:00 2001 From: gecheng Date: Fri, 22 Aug 2025 16:02:03 +0800 Subject: [PATCH 26/76] =?UTF-8?q?fuzz=E7=94=A8=E4=BE=8B=E9=97=AE=E9=A2=98?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp index 0b12c1577..9244755f8 100644 --- a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp @@ -26,7 +26,8 @@ void SyncStrategiesFuzz001(FuzzedDataProvider &provider) { int32_t user = provider.ConsumeIntegral(); std::string bundleName = provider.ConsumeRandomLengthString(100); - NetworkDelegateNormalImpl::Init(); + static bool initialized = NetworkDelegateNormalImpl::Init(); + (void)initialized; NetworkSyncStrategy strategy; StoreInfo storeInfo; storeInfo.user = user; -- Gitee From 3f8a04eb382304e3718fe87f409755caa3953d76 Mon Sep 17 00:00:00 2001 From: gecheng Date: Fri, 22 Aug 2025 16:27:48 +0800 Subject: [PATCH 27/76] =?UTF-8?q?fuzz=E7=94=A8=E4=BE=8B=E9=97=AE=E9=A2=98?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn index 26a132ffe..2beeabbef 100644 --- a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/BUILD.gn @@ -41,6 +41,7 @@ ohos_fuzztest("SyncStrategiesFuzzTest") { deps = [ "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", "${data_service_path}/framework:distributeddatasvcfwk", "${data_service_path}/service/cloud:distributeddata_cloud", "${data_service_path}/service/common:distributeddata_common", -- Gitee From 693ffe98dd2a54044841abb5b526c832fd614ffc Mon Sep 17 00:00:00 2001 From: MengYao Date: Fri, 22 Aug 2025 17:26:56 +0800 Subject: [PATCH 28/76] =?UTF-8?q?rdb=E6=9C=8D=E5=8A=A1=E7=AB=AF=E5=87=8F?= =?UTF-8?q?=E5=B0=91load=E7=9A=84=E6=AC=A1=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: MengYao --- .../include/metadata/appid_meta_data.h | 1 + .../include/metadata/secret_key_meta_data.h | 2 ++ .../framework/metadata/appid_meta_data.cpp | 5 ++++ .../metadata/secret_key_meta_data.cpp | 11 +++++++++ .../service/rdb/rdb_service_impl.cpp | 16 ++++++++++++- .../service/test/rdb_service_impl_test.cpp | 24 +++++++++++++++++-- 6 files changed, 56 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/framework/include/metadata/appid_meta_data.h b/services/distributeddataservice/framework/include/metadata/appid_meta_data.h index 1707a360c..627440f1a 100644 --- a/services/distributeddataservice/framework/include/metadata/appid_meta_data.h +++ b/services/distributeddataservice/framework/include/metadata/appid_meta_data.h @@ -26,6 +26,7 @@ struct API_EXPORT AppIDMetaData final : public Serializable { API_EXPORT AppIDMetaData(); API_EXPORT AppIDMetaData(const std::string &appId, const std::string &bundleName); API_EXPORT ~AppIDMetaData(); + API_EXPORT bool operator==(const AppIDMetaData &appIdMetaData) const; API_EXPORT bool Marshal(json &node) const override; API_EXPORT bool Unmarshal(const json &node) override; API_EXPORT std::string GetKey() const; diff --git a/services/distributeddataservice/framework/include/metadata/secret_key_meta_data.h b/services/distributeddataservice/framework/include/metadata/secret_key_meta_data.h index cb546472b..57a95079d 100644 --- a/services/distributeddataservice/framework/include/metadata/secret_key_meta_data.h +++ b/services/distributeddataservice/framework/include/metadata/secret_key_meta_data.h @@ -27,6 +27,8 @@ struct API_EXPORT SecretKeyMetaData final : public Serializable { API_EXPORT SecretKeyMetaData(); API_EXPORT ~SecretKeyMetaData(); + API_EXPORT bool operator==(const SecretKeyMetaData &secretKey) const; + API_EXPORT bool operator!=(const SecretKeyMetaData &secretKey) const; API_EXPORT bool Marshal(json &node) const override; API_EXPORT bool Unmarshal(const json &node) override; diff --git a/services/distributeddataservice/framework/metadata/appid_meta_data.cpp b/services/distributeddataservice/framework/metadata/appid_meta_data.cpp index 71b61792f..1a1a7c856 100644 --- a/services/distributeddataservice/framework/metadata/appid_meta_data.cpp +++ b/services/distributeddataservice/framework/metadata/appid_meta_data.cpp @@ -43,6 +43,11 @@ AppIDMetaData::~AppIDMetaData() { } +bool AppIDMetaData::operator==(const AppIDMetaData &appIdMetaData) const +{ + return (appId == appIdMetaData.appId && bundleName == appIdMetaData.bundleName); +} + std::string AppIDMetaData::GetKey() const { return appId; diff --git a/services/distributeddataservice/framework/metadata/secret_key_meta_data.cpp b/services/distributeddataservice/framework/metadata/secret_key_meta_data.cpp index 3af423fb1..08e1ef42f 100644 --- a/services/distributeddataservice/framework/metadata/secret_key_meta_data.cpp +++ b/services/distributeddataservice/framework/metadata/secret_key_meta_data.cpp @@ -27,6 +27,17 @@ SecretKeyMetaData::~SecretKeyMetaData() nonce.assign(nonce.size(), 0); } +bool SecretKeyMetaData::operator==(const SecretKeyMetaData &secretKey) const +{ + return sKey == secretKey.sKey && nonce == secretKey.nonce && storeType == secretKey.storeType && + area == secretKey.area; +} + +bool SecretKeyMetaData::operator!=(const SecretKeyMetaData &secretKey) const +{ + return !(*this == secretKey); +} + bool SecretKeyMetaData::Marshal(json &node) const { SetValue(node[GET_NAME(time)], time); diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp index 43c0c7cfb..ae302db1e 100644 --- a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp +++ b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp @@ -914,13 +914,17 @@ void RdbServiceImpl::SaveSecretKeyMeta(const StoreMetaData &metaData, const std: auto encryptKey = CryptoManager::GetInstance().Encrypt(password, encryptParams); if (!encryptKey.empty() && !encryptParams.nonce.empty()) { SecretKeyMetaData secretKey; + SecretKeyMetaData oldSecretKey; secretKey.storeType = metaData.storeType; secretKey.area = metaData.area; secretKey.sKey = encryptKey; secretKey.nonce = encryptParams.nonce; auto time = system_clock::to_time_t(system_clock::now()); secretKey.time = { reinterpret_cast(&time), reinterpret_cast(&time) + sizeof(time) }; - MetaDataManager::GetInstance().SaveMeta(metaData.GetSecretKey(), secretKey, true); + if (!MetaDataManager::GetInstance().LoadMeta(metaData.GetSecretKey(), oldSecretKey, true) || + secretKey != oldSecretKey) { + MetaDataManager::GetInstance().SaveMeta(metaData.GetSecretKey(), secretKey, true); + } } SecretKeyMetaData cloneKey; auto metaKey = metaData.GetCloneSecretKey(); @@ -988,8 +992,12 @@ int32_t RdbServiceImpl::AfterOpen(const RdbSyncerParam ¶m) bool RdbServiceImpl::SaveAppIDMeta(const StoreMetaData &meta, const StoreMetaData &old) { AppIDMetaData appIdMeta; + AppIDMetaData oldAppIdMeta; appIdMeta.bundleName = meta.bundleName; appIdMeta.appId = meta.appId; + if (MetaDataManager::GetInstance().LoadMeta(appIdMeta.GetKey(), appIdMeta, true) && appIdMeta == oldAppIdMeta) { + return true; + } if (!MetaDataManager::GetInstance().SaveMeta(appIdMeta.GetKey(), appIdMeta, true)) { ZLOGE("meta bundle:%{public}s store:%{public}s type:%{public}d->%{public}d encrypt:%{public}d->%{public}d " "area:%{public}d->%{public}d", meta.bundleName.c_str(), meta.GetStoreAlias().c_str(), old.storeType, @@ -1741,6 +1749,12 @@ int32_t RdbServiceImpl::SavePromiseInfo(const StoreMetaData &metaData, const Rdb return RDB_OK; } StoreMetaDataLocal localMeta; + if (MetaDataManager::GetInstance().LoadMeta(metaData.GetKeyLocal(), localMeta, true)) { + if (param.tokenIds_ == localMeta.promiseInfo.tokenIds && param.uids_ == localMeta.promiseInfo.uids && + param.permissionNames_ == localMeta.promiseInfo.permissionNames) { + return RDB_OK; + } + } localMeta.promiseInfo.tokenIds = param.tokenIds_; localMeta.promiseInfo.uids = param.uids_; localMeta.promiseInfo.permissionNames = param.permissionNames_; diff --git a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp index abe248836..f144db0ff 100644 --- a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp @@ -25,6 +25,7 @@ #include "device_matrix.h" #include "event_center.h" #include "ipc_skeleton.h" +#include "metadata/appid_meta_data.h" #include "metadata/capability_meta_data.h" #include "metadata/meta_data_manager.h" #include "metadata/store_meta_data.h" @@ -791,15 +792,34 @@ HWTEST_F(RdbServiceImplTest, AfterOpen002, TestSize.Level0) */ HWTEST_F(RdbServiceImplTest, AfterOpen003, TestSize.Level0) { - EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyWithoutPath(), metaData_, false), true); + EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true), true); RdbServiceImpl service; RdbSyncerParam param; param.bundleName_ = metaData_.bundleName; param.storeName_ = metaData_.storeId; + param.tokenIds_ = {123}; + param.uids_ = {123}; + param.permissionNames_ = {}; + AppIDMetaData appIdMeta; + appIdMeta.bundleName = metaData_.bundleName; + appIdMeta.appId = metaData_.appId; + EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(appIdMeta.GetKey(), appIdMeta, true), true); + StoreMetaDataLocal localMeta; + EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true), true); int32_t result = service.AfterOpen(param); - EXPECT_EQ(result, RDB_OK); EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true); + param.tokenIds_ = {123}; + param.uids_ = {456}; + result = service.AfterOpen(param); + EXPECT_EQ(result, RDB_OK); + param.permissionNames_ = {"com.example.myapplication"}; + result = service.AfterOpen(param); + EXPECT_EQ(result, RDB_OK); + + EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true), true); + EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true), true); + EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(appIdMeta.GetKey(), true), true); } /** -- Gitee From c7f72b0e4086239c29b311e609d4c4a30d5599fd Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Fri, 22 Aug 2025 17:54:46 +0800 Subject: [PATCH 29/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 55 +++++++++++-------- 1 file changed, 31 insertions(+), 24 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 003dad5fe..b483ac323 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -16,6 +16,7 @@ #include "sync_manager.h" #include +#include #include "account/account_delegate.h" #include "bootstrap.h" @@ -1137,32 +1138,38 @@ void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, con std::vector SyncManager::NetworkRecoveryManager::GetAppList(const int32_t user, bool timeout) { - std::vector appList; - if (timeout) { - CloudInfo cloud; - cloud.user = user; - if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { - ZLOGE("load cloud info fail, user:%{public}d", user); - return appList; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - for (const auto &store : stores) { - appList.push_back(store.bundleName); - } - for (const auto &app : cloud.apps) { - if (std::find(appList.begin(), appList.end(), app.second.bundleName) == appList.end()) { - appList.push_back(app.second.bundleName); - } - } - } else { + if (!timeout) { std::lock_guard lock(syncAppsMutex_); - auto item = currentEvent_->syncApps.find(user); - if (item == currentEvent_->syncApps.end()) { - return appList; + if (auto it = currentEvent_->syncApps.find(user); it != currentEvent_->syncApps.end()) { + return it->second; + } + return {}; + } + + CloudInfo cloud; + cloud.user = user; + if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { + ZLOGE("load cloud info fail, user:%{public}d", user); + return {}; + } + const size_t totalCount = cloud.apps.size(); + std::vector appList; + appList.reserve(totalCount); + std::unordered_set uniqueSet; + uniqueSet.reserve(totalCount); + auto addApp = [&](const std::string &bundleName) { + if (uniqueSet.insert(bundleName).second) { + appList.push_back(bundleName); } - appList = item->second; + }; + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + for (const auto &store : stores) { + addApp(store.bundleName); + } + for (const auto &[_, app] : cloud.apps) { + addApp(app.bundleName); } return appList; } -- Gitee From 5b48e2b94cc302fa4a7e77a97752f5a09240ae95 Mon Sep 17 00:00:00 2001 From: MengYao Date: Fri, 22 Aug 2025 19:27:43 +0800 Subject: [PATCH 30/76] fix Signed-off-by: MengYao --- .../distributeddataservice/service/rdb/rdb_service_impl.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp index ae302db1e..b62f047ea 100644 --- a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp +++ b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp @@ -995,7 +995,7 @@ bool RdbServiceImpl::SaveAppIDMeta(const StoreMetaData &meta, const StoreMetaDat AppIDMetaData oldAppIdMeta; appIdMeta.bundleName = meta.bundleName; appIdMeta.appId = meta.appId; - if (MetaDataManager::GetInstance().LoadMeta(appIdMeta.GetKey(), appIdMeta, true) && appIdMeta == oldAppIdMeta) { + if (MetaDataManager::GetInstance().LoadMeta(appIdMeta.GetKey(), oldAppIdMeta, true) && appIdMeta == oldAppIdMeta) { return true; } if (!MetaDataManager::GetInstance().SaveMeta(appIdMeta.GetKey(), appIdMeta, true)) { -- Gitee From 0818d761e4cfcebb072d12a09f4bc70778d7b267 Mon Sep 17 00:00:00 2001 From: gecheng Date: Sat, 23 Aug 2025 18:26:29 +0800 Subject: [PATCH 31/76] =?UTF-8?q?fuzz=E7=94=A8=E4=BE=8B=E9=97=AE=E9=A2=98?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp index 9244755f8..6a845885e 100644 --- a/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/syncstrategies_fuzzer/syncstrategies_fuzzer.cpp @@ -26,8 +26,8 @@ void SyncStrategiesFuzz001(FuzzedDataProvider &provider) { int32_t user = provider.ConsumeIntegral(); std::string bundleName = provider.ConsumeRandomLengthString(100); - static bool initialized = NetworkDelegateNormalImpl::Init(); - (void)initialized; + static NetworkDelegateNormalImpl delegate; + NetworkDelegate::RegisterNetworkInstance(&delegate); NetworkSyncStrategy strategy; StoreInfo storeInfo; storeInfo.user = user; -- Gitee From 77bdfb49979038a8fea5b5f75d5ef9e4c46137cf Mon Sep 17 00:00:00 2001 From: Cuiziyuan Date: Sun, 24 Aug 2025 16:56:06 +0800 Subject: [PATCH 32/76] =?UTF-8?q?=E8=93=9D=E9=BB=84=E5=B7=AE=E5=BC=82?= =?UTF-8?q?=E6=B6=88=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Cuiziyuan --- bundle.json | 3 +-- services/distributeddataservice/service/data_share/BUILD.gn | 1 - .../service/data_share/data_share_service_impl.cpp | 4 +--- .../service/data_share/data_share_service_impl.h | 1 - .../test/fuzztest/datashareserviceimpl_fuzzer/BUILD.gn | 1 + .../test/fuzztest/datashareservicestub_fuzzer/BUILD.gn | 2 +- 6 files changed, 4 insertions(+), 8 deletions(-) diff --git a/bundle.json b/bundle.json index f726ee71c..8b8985701 100644 --- a/bundle.json +++ b/bundle.json @@ -94,8 +94,7 @@ "openssl", "json", "dmsfwk", - "data_object", - "init" + "data_object" ], "third_party": [ "libuv", diff --git a/services/distributeddataservice/service/data_share/BUILD.gn b/services/distributeddataservice/service/data_share/BUILD.gn index 788eceec2..f39ed7a35 100644 --- a/services/distributeddataservice/service/data_share/BUILD.gn +++ b/services/distributeddataservice/service/data_share/BUILD.gn @@ -130,7 +130,6 @@ ohos_source_set("data_share_service") { "hicollie:libhicollie", "hilog:libhilog", "hisysevent:libhisysevent", - "init:libbegetutil", "ipc:ipc_core", "json:nlohmann_json_static", "kv_store:datamgr_common", diff --git a/services/distributeddataservice/service/data_share/data_share_service_impl.cpp b/services/distributeddataservice/service/data_share/data_share_service_impl.cpp index 0b3e7c81b..75730097c 100644 --- a/services/distributeddataservice/service/data_share/data_share_service_impl.cpp +++ b/services/distributeddataservice/service/data_share/data_share_service_impl.cpp @@ -60,7 +60,6 @@ #include "utils/anonymous.h" #include "xcollie.h" #include "log_debug.h" -#include "parameters.h" #include "dataproxy_handle_common.h" #include "proxy_data_manager.h" #include "datashare_observer.h" @@ -1144,8 +1143,7 @@ bool DataShareServiceImpl::VerifyAcrossAccountsPermission(int32_t currentUserId, if (currentUserId == 0 || currentUserId == visitedUserId) { return true; } - return system::GetBoolParameter(CONNECT_SUPPORT_CROSS_USER, false) && - PermitDelegate::VerifyPermission(acrossAccountsPermission, callerTokenId); + return PermitDelegate::VerifyPermission(acrossAccountsPermission, callerTokenId); } std::pair DataShareServiceImpl::ExecuteEx(const std::string &uri, const std::string &extUri, diff --git a/services/distributeddataservice/service/data_share/data_share_service_impl.h b/services/distributeddataservice/service/data_share/data_share_service_impl.h index 41b2965e5..c86cf2fa2 100644 --- a/services/distributeddataservice/service/data_share/data_share_service_impl.h +++ b/services/distributeddataservice/service/data_share/data_share_service_impl.h @@ -160,7 +160,6 @@ private: static constexpr const char *PROXY_URI_SCHEMA = "datashareproxy"; static constexpr const char *EXT_URI_SCHEMA = "datashare://"; static constexpr const char *NO_PERMISSION = "noPermission"; - static constexpr const char *CONNECT_SUPPORT_CROSS_USER = "const.abilityms.connect_support_cross_user"; PublishStrategy publishStrategy_; GetDataStrategy getDataStrategy_; SubscribeStrategy subscribeStrategy_; diff --git a/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/BUILD.gn index baa4fa6ef..22cb65f5e 100644 --- a/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/datashareserviceimpl_fuzzer/BUILD.gn @@ -98,6 +98,7 @@ ohos_fuzztest("DataShareServiceImplFuzzTest") { "${data_service_path}/service/data_share/sys_event_subscriber.cpp", "${data_service_path}/service/kvdb/user_delegate.cpp", "${data_service_path}/service/permission/src/permit_delegate.cpp", + "${data_service_path}/service/permission/src/permission_validator.cpp", "datashareserviceimpl_fuzzer.cpp", ] diff --git a/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/BUILD.gn index 582498375..2b158d7b0 100644 --- a/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/BUILD.gn @@ -96,6 +96,7 @@ ohos_fuzztest("DataShareServiceStubFuzzTest") { "${data_service_path}/service/data_share/sys_event_subscriber.cpp", "${data_service_path}/service/kvdb/user_delegate.cpp", "${data_service_path}/service/permission/src/permit_delegate.cpp", + "${data_service_path}/service/permission/src/permission_validator.cpp", "datashareservicestub_fuzzer.cpp", ] @@ -126,7 +127,6 @@ ohos_fuzztest("DataShareServiceStubFuzzTest") { "hilog:libhilog", "hisysevent:libhisysevent", "huks:libhukssdk", - "init:libbegetutil", "ipc:ipc_core", "kv_store:distributeddata_inner", "kv_store:distributeddb", -- Gitee From 1b1f17d747a88ee032fe9ffee30cbf73f022d0d9 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Sat, 23 Aug 2025 10:51:19 +0800 Subject: [PATCH 33/76] fix: Signed-off-by: weishaoxiong --- .../service/test/BUILD.gn | 1 + .../service/test/cloud_service_impl_test.cpp | 174 ++++++++++++++++++ 2 files changed, 175 insertions(+) diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn index 1f6ecbcfd..5ef8ef536 100644 --- a/services/distributeddataservice/service/test/BUILD.gn +++ b/services/distributeddataservice/service/test/BUILD.gn @@ -187,6 +187,7 @@ ohos_unittest("CloudServiceImplTest") { "${data_service_path}/service/cloud/sync_strategies/network_sync_strategy.cpp", "${data_service_path}/service/test/mock/checker_mock.cpp", "cloud_service_impl_test.cpp", + "mock/account_delegate_mock.cpp", ] configs = [ ":module_private_config" ] diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp index dbe572a55..d2d31f17e 100644 --- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp @@ -40,6 +40,7 @@ #include "metadata/meta_data_manager.h" #include "metadata/store_meta_data.h" #include "metadata/store_meta_data_local.h" +#include "mock/account_delegate_mock.h" #include "mock/db_store_mock.h" #include "mock/general_store_mock.h" #include "mock/meta_data_manager_mock.h" @@ -68,6 +69,8 @@ static constexpr const char *TEST_CLOUD_BUNDLE = "test_cloud_bundleName"; static constexpr const char *TEST_CLOUD_APPID = "test_cloud_appid"; static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store"; static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1"; +constexpr const int32_t DISCONNECT_TIME = 21; +constexpr const int32_t MOCK_USER = 200; class CloudServiceImplTest : public testing::Test { public: static void SetUpTestCase(void); @@ -78,6 +81,7 @@ public: static std::shared_ptr cloudServiceImpl_; static inline std::shared_ptr metaDataManagerMock = nullptr; static NetworkDelegateMock delegate_; + static inline AccountDelegateMock *accountDelegateMock = nullptr; }; std::shared_ptr CloudServiceImplTest::cloudServiceImpl_ = std::make_shared(); @@ -778,5 +782,175 @@ HWTEST_F(ComponentConfigTest, ComponentConfig, TestSize.Level0) EXPECT_EQ(node["constructor"], componentConfig.constructor); EXPECT_EQ(node["destructor"], componentConfig.destructor); } + +/** + * @tc.name: NetworkRecoveryTest001 + * @tc.desc: test the compensatory sync strategy for network disconnection times of less than 20 hours + * @tc.type: FUNC + * @tc.require: + * @tc.author: + */ +HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest001, TestSize.Level0) +{ + ASSERT_NE(cloudServiceImpl_, nullptr); + accountDelegateMock = new (std::nothrow) AccountDelegateMock(); + if (accountDelegateMock != nullptr) { + AccountDelegate::instance_ = nullptr; + AccountDelegate::RegisterAccountInstance(accountDelegateMock); + } + + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + // 2 means that the QueryForegroundUsers interface will be called twice + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) + .Times(2) + .WillRepeatedly(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + std::string bundleName = "com.ohos.test"; + CloudInfo::AppInfo appInfo; + appInfo.bundleName = bundleName; + std::map apps; + apps.emplace(bundleName, appInfo); + CloudInfo cloudInfo; + cloudInfo.apps = apps; + cloudInfo.user = MOCK_USER; + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_NE(recoveryManager.currentEvent_, nullptr); + recoveryManager.RecordSyncApps(MOCK_USER, bundleName); + recoveryManager.RecordSyncApps(MOCK_USER, bundleName); + EXPECT_EQ(recoveryManager.currentEvent_->syncApps.size(), 1); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); +} + +/** + * @tc.name: NetworkRecoveryTest002 + * @tc.desc: test the compensatory sync strategy for network disconnection times of more than 20 hours + * @tc.type: FUNC + * @tc.require: + * @tc.author: + */ +HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest002, TestSize.Level0) +{ + ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + // 2 means that the QueryForegroundUsers interface will be called twice + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) + .Times(2) + .WillRepeatedly(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_NE(recoveryManager.currentEvent_, nullptr); + recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); +} + +/** + * @tc.name: NetworkRecoveryTest003 + * @tc.desc: The test only calls the network connection interface but not disconnect + * @tc.type: FUNC + * @tc.require: + * @tc.author: + */ +HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest003, TestSize.Level0) +{ + ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + recoveryManager.RecordSyncApps(MOCK_USER, ""); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); +} + +/** + * @tc.name: NetworkRecoveryTest004 + * @tc.desc: The QueryForegroundUsers interface call fails when the network is restored + * @tc.type: FUNC + * @tc.require: + * @tc.author: + */ +HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) +{ + ASSERT_NE(cloudServiceImpl_, nullptr); + auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + recoveryManager.OnNetworkDisconnected(); + auto returnWithUserList = + [](const std::vector &users) { + return Invoke([=](std::vector &outUsers) -> bool { + outUsers = users; + return true; + }); + }; + + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) + .WillOnce(returnWithUserList({ MOCK_USER })) + .WillOnce(Return(false)); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); + + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) + .WillOnce(returnWithUserList({ MOCK_USER })) + .WillOnce(returnWithUserList({})); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_NE(recoveryManager.currentEvent_, nullptr); +} + +/** + * @tc.name: NetworkRecoveryTest005 + * @tc.desc: The test network connection interface call fails when the load cloudInfo failed + * @tc.type: FUNC + * @tc.require: + * @tc.author: + */ +HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest005, TestSize.Level0) +{ + ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + // 2 means that the QueryForegroundUsers interface will be called twice + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) + .Times(2) + .WillRepeatedly(Invoke([&](std::vector &users) -> bool { + users = { MOCK_USER }; + return true; + })); + CloudInfo cloudInfo; + cloudInfo.user = MOCK_USER; + MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true); + auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_NE(recoveryManager.currentEvent_, nullptr); + recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); + cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); + if (accountDelegateMock != nullptr) { + delete accountDelegateMock; + accountDelegateMock = nullptr; + } +} } // namespace DistributedDataTest } // namespace OHOS::Test \ No newline at end of file -- Gitee From 9648ce9da19d2a8f31c28cf0977adc507a30dc22 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Mon, 25 Aug 2025 11:46:44 +0800 Subject: [PATCH 34/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 32 +++++++++---------- .../service/cloud/sync_manager.h | 4 +-- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index b483ac323..401b3e6bf 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -1093,6 +1093,7 @@ int32_t SyncManager::ConvertValidGeneralCode(int32_t code) void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() { ZLOGI("network disconnected."); + std::lock_guard lock(eventMutex_); currentEvent_ = std::make_unique(); currentEvent_->disconnectTime = std::chrono::system_clock::now(); } @@ -1100,12 +1101,17 @@ void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() void SyncManager::NetworkRecoveryManager::OnNetworkConnected() { ZLOGI("network connected start."); - if (!currentEvent_) { - ZLOGE("network connected, but currentEvent_ is not initialized."); - return; + std::unique_ptr event; + { + std::lock_guard lock(eventMutex_); + if (!currentEvent_) { + ZLOGE("network connected, but currentEvent_ is not initialized."); + return; + } + event = std::move(currentEvent_); } auto now = std::chrono::system_clock::now(); - auto duration = now - currentEvent_->disconnectTime; + auto duration = now - event->disconnectTime; auto hours = std::chrono::duration_cast(duration).count(); bool timeout = (hours > TIMEOUT_TIME); std::vector users; @@ -1114,21 +1120,23 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() return; } for (auto user : users) { - auto syncApps = GetAppList(user, timeout); + std::vector syncApps(event->syncApps[user]); + if (timeout) { + syncApps = GetAppList(user); + } for (const auto &bundleName : syncApps) { ZLOGI("sync start bundleName:%{public}s, user:%{public}d", bundleName.c_str(), user); syncManager_.DoCloudSync(SyncInfo(user, bundleName, "", {}, MODE_ONLINE)); } } - currentEvent_.reset(); ZLOGI("network connected end, network disconnect duration :%{public}ld hours", hours); } void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, const std::string &bundleName) { + std::lock_guard lock(eventMutex_); if (currentEvent_) { ZLOGI("record sync user:%{public}d, bundleName:%{public}s", user, bundleName.c_str()); - std::lock_guard lock(syncAppsMutex_); auto &syncApps = currentEvent_->syncApps[user]; if (std::find(syncApps.begin(), syncApps.end(), bundleName) == syncApps.end()) { syncApps.push_back(bundleName); @@ -1136,16 +1144,8 @@ void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, con } } -std::vector SyncManager::NetworkRecoveryManager::GetAppList(const int32_t user, bool timeout) +std::vector SyncManager::NetworkRecoveryManager::GetAppList(const int32_t user) { - if (!timeout) { - std::lock_guard lock(syncAppsMutex_); - if (auto it = currentEvent_->syncApps.find(user); it != currentEvent_->syncApps.end()) { - return it->second; - } - return {}; - } - CloudInfo cloud; cloud.user = user; if (!MetaDataManager::GetInstance().LoadMeta(cloud.GetKey(), cloud, true)) { diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index ef2cc1b6e..89e36115b 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -114,12 +114,12 @@ public: void RecordSyncApps(const int32_t user, const std::string &bundleName); private: - std::vector GetAppList(const int32_t user, bool timeout); + std::vector GetAppList(const int32_t user); struct NetWorkEvent { std::chrono::system_clock::time_point disconnectTime; std::map> syncApps; }; - std::mutex syncAppsMutex_; + std::mutex eventMutex_; std::unique_ptr currentEvent_; SyncManager &syncManager_; }; -- Gitee From 429af4afbef1dde25275e421d29040016f35b5a5 Mon Sep 17 00:00:00 2001 From: wanxiaoqing Date: Mon, 25 Aug 2025 16:06:59 +0800 Subject: [PATCH 35/76] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=B7=AE=E5=BC=82?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wanxiaoqing --- .../test/udmf_service_impl_mock_test.cpp | 28 +-- .../service/test/udmf_service_impl_test.cpp | 163 +++++++++++++++++- .../udmf/preprocess/preprocess_utils.cpp | 1 - .../service/udmf/store/store.h | 4 + .../service/udmf/udmf_service_impl.cpp | 3 +- .../service/udmf/udmf_service_stub.h | 1 - 6 files changed, 181 insertions(+), 19 deletions(-) diff --git a/services/distributeddataservice/service/test/udmf_service_impl_mock_test.cpp b/services/distributeddataservice/service/test/udmf_service_impl_mock_test.cpp index 9daa166f4..ec2539109 100644 --- a/services/distributeddataservice/service/test/udmf_service_impl_mock_test.cpp +++ b/services/distributeddataservice/service/test/udmf_service_impl_mock_test.cpp @@ -73,25 +73,27 @@ HWTEST_F(UdmfServiceImplMockTest, IsNeedMetaSyncTest001, TestSize.Level0) StoreMetaData meta = StoreMetaData("100", "distributeddata", "drag"); std::vector devices = {"remote_device"}; - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(Return(false)); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(false)) + .WillOnce(testing::Return(false)); auto isNeedSync = udmfServiceImpl.IsNeedMetaSync(meta, devices); EXPECT_EQ(isNeedSync, true); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(Return(false)); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(false)) + .WillOnce(testing::Return(true)); isNeedSync = udmfServiceImpl.IsNeedMetaSync(meta, devices); EXPECT_EQ(isNeedSync, true); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(Return(true)) - .WillOnce(Return(false)); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(true)) + .WillOnce(testing::Return(false)); isNeedSync = udmfServiceImpl.IsNeedMetaSync(meta, devices); EXPECT_EQ(isNeedSync, true); - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(Return(true)) - .WillOnce(Return(true)); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(true)) + .WillOnce(testing::Return(true)); isNeedSync = udmfServiceImpl.IsNeedMetaSync(meta, devices); EXPECT_EQ(isNeedSync, true); } @@ -111,9 +113,9 @@ HWTEST_F(UdmfServiceImplMockTest, IsNeedMetaSyncTest002, TestSize.Level0) StoreMetaData meta = StoreMetaData("100", "distributeddata", "drag"); std::vector devices = {"remote_device"}; - EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)) - .WillOnce(Return(false)) - .WillOnce(Return(false)); + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(false)) + .WillOnce(testing::Return(false)); auto isNeedSync = udmfServiceImpl.IsNeedMetaSync(meta, devices); EXPECT_EQ(isNeedSync, true); // mock mask diff --git a/services/distributeddataservice/service/test/udmf_service_impl_test.cpp b/services/distributeddataservice/service/test/udmf_service_impl_test.cpp index d5ae9fab1..541089c74 100644 --- a/services/distributeddataservice/service/test/udmf_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/udmf_service_impl_test.cpp @@ -32,13 +32,12 @@ #include "token_setproc.h" using namespace testing::ext; -using namespace OHOS::DistributedData; using namespace OHOS::Security::AccessToken; using namespace OHOS::UDMF; -using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; using Entry = DistributedDB::Entry; using Key = DistributedDB::Key; using Value = DistributedDB::Value; +using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; using UnifiedData = OHOS::UDMF::UnifiedData; using Summary = OHOS::UDMF::Summary; namespace OHOS::Test { @@ -411,7 +410,7 @@ HWTEST_F(UdmfServiceImplTest, SyncTest001, TestSize.Level0) query.tokenId = 1; query.intention = UD_INTENTION_DRAG; UdmfServiceImpl udmfServiceImpl; - StoreMetaData meta = StoreMetaData("100", "distributeddata", "drag"); + DistributedData::StoreMetaData meta = DistributedData::StoreMetaData("100", "distributeddata", "drag"); std::vector devices = {"remote_device"}; auto ret = udmfServiceImpl.Sync(query, devices); @@ -541,6 +540,164 @@ HWTEST_F(UdmfServiceImplTest, IsValidInput004, TestSize.Level1) EXPECT_FALSE(result); } +/** + * @tc.name: UpdateData002 + * @tc.desc: invalid parameter + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, UpdateData002, TestSize.Level1) +{ + QueryOption query; + query.intention = Intention::UD_INTENTION_DATA_HUB; + query.key = "udmf://DataHub/aaa/N]2fIEMbrJj@wp:jMuPa7"; + query.tokenId = 99999; + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + + UdmfServiceImpl impl; + EXPECT_NE(impl.UpdateData(query, unifiedData), E_OK); +} + +/** + * @tc.name: UpdateData003 + * @tc.desc: invalid parameter + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, UpdateData003, TestSize.Level1) +{ + QueryOption query; + query.intention = Intention::UD_INTENTION_DATA_HUB; + query.key = "udmf://DataHub/aaa/N]2fIEMbrJj@wp:jMuPa7"; + query.tokenId = static_cast(IPCSkeleton::GetCallingTokenID()); + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + + UdmfServiceImpl impl; + EXPECT_NE(impl.UpdateData(query, unifiedData), E_OK); +} + +/** + * @tc.name: UpdateData004 + * @tc.desc: invalid parameter + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, UpdateData004, TestSize.Level1) +{ + QueryOption query; + UnifiedData unifiedData; + + query.key = "invalid_key"; + UdmfServiceImpl impl; + EXPECT_EQ(impl.UpdateData(query, unifiedData), E_INVALID_PARAMETERS); +} + +/** +* @tc.name: SaveData002 +* @tc.desc: invalid parameter +* @tc.type: FUNC +*/ +HWTEST_F(UdmfServiceImplTest, SaveData002, TestSize.Level1) +{ + CustomOption option; + QueryOption query; + UnifiedData unifiedData; + std::string key = ""; + + UdmfServiceImpl impl; + EXPECT_EQ(impl.SaveData(option, unifiedData, key), E_INVALID_PARAMETERS); +} + +/** +* @tc.name: SaveData003 +* @tc.desc: invalid parameter +* @tc.type: FUNC +*/ +HWTEST_F(UdmfServiceImplTest, SaveData003, TestSize.Level1) +{ + CustomOption option; + QueryOption query; + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + std::string key = ""; + option.intention = Intention::UD_INTENTION_BASE; + + UdmfServiceImpl impl; + EXPECT_EQ(impl.SaveData(option, unifiedData, key), E_INVALID_PARAMETERS); +} + +/** +* @tc.name: SaveData004 +* @tc.desc: invalid parameter +* @tc.type: FUNC +*/ +HWTEST_F(UdmfServiceImplTest, SaveData004, TestSize.Level1) +{ + CustomOption option; + QueryOption query; + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + std::string key = ""; + option.intention = Intention::UD_INTENTION_DATA_HUB; + option.tokenId = 99999; + + UdmfServiceImpl impl; + EXPECT_NE(impl.SaveData(option, unifiedData, key), E_OK); +} + +/** + * @tc.name: IsValidInput005 + * @tc.desc: valid input + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, IsValidInput005, TestSize.Level1) +{ + QueryOption query; + query.intention = Intention::UD_INTENTION_DRAG; + query.key = "udmf://drag/aaa/N]2fIEMbrJj@wp:jMuPa7"; + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + UnifiedKey key("udmf://drag/aaa/N]2fIEMbrJj@wp:jMuPa7"); + EXPECT_TRUE(key.IsValid()); + + UdmfServiceImpl impl; + bool result = impl.IsValidInput(query, unifiedData, key); + EXPECT_FALSE(result); +} + +/** + * @tc.name: PushDelayData001 + * @tc.desc: valid input + * @tc.type: FUNC + */ +HWTEST_F(UdmfServiceImplTest, PushDelayData001, TestSize.Level1) +{ + UnifiedData unifiedData; + auto record1 = std::make_shared(); + auto record2 = std::make_shared(); + unifiedData.AddRecord(record1); + unifiedData.AddRecord(record2); + std::string key = "invalid key"; + + UdmfServiceImpl impl; + auto result = impl.PushDelayData(key, unifiedData); + EXPECT_NE(result, E_OK); +} + /** * @tc.name: CheckAppId001 * @tc.desc: invalid bundleName diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 597cc9a7a..5a8f2e146 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -16,7 +16,6 @@ #include "preprocess_utils.h" -#include #include #include "bundle_info.h" diff --git a/services/distributeddataservice/service/udmf/store/store.h b/services/distributeddataservice/service/udmf/store/store.h index 1b215e250..a21f24b56 100644 --- a/services/distributeddataservice/service/udmf/store/store.h +++ b/services/distributeddataservice/service/udmf/store/store.h @@ -16,6 +16,10 @@ #ifndef UDMF_STORE_H #define UDMF_STORE_H +#include +#include +#include + #include "unified_data.h" namespace OHOS { diff --git a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp index 0611b796f..4db92da93 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_impl.cpp +++ b/services/distributeddataservice/service/udmf/udmf_service_impl.cpp @@ -1197,7 +1197,8 @@ bool UdmfServiceImpl::IsValidOptionsNonDrag(UnifiedKey &key, const std::string & return false; } -int32_t UdmfServiceImpl::SetDelayInfo(const DataLoadInfo &dataLoadInfo, sptr iUdmfNotifier, std::string &key) +int32_t UdmfServiceImpl::SetDelayInfo(const DataLoadInfo &dataLoadInfo, sptr iUdmfNotifier, + std::string &key) { std::string bundleName; std::string specificBundleName; diff --git a/services/distributeddataservice/service/udmf/udmf_service_stub.h b/services/distributeddataservice/service/udmf/udmf_service_stub.h index c5f617a9f..3ca1214b0 100644 --- a/services/distributeddataservice/service/udmf/udmf_service_stub.h +++ b/services/distributeddataservice/service/udmf/udmf_service_stub.h @@ -45,7 +45,6 @@ private: int32_t OnRemoveAppShareOption(MessageParcel &data, MessageParcel &reply); int32_t OnObtainAsynProcess(MessageParcel &data, MessageParcel &reply); int32_t OnClearAsynProcessByKey(MessageParcel &data, MessageParcel &reply); - int32_t OnInvokeHap(MessageParcel &data, MessageParcel &reply); int32_t OnPushDelayData(MessageParcel &data, MessageParcel &reply); int32_t OnSetDelayInfo(MessageParcel &data, MessageParcel &reply); int32_t OnGetDataIfAvailable(MessageParcel &data, MessageParcel &reply); -- Gitee From 289f7ba34944ed6401ab7f86394dbd62bb0baf02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=AE=81=E7=AB=9E=E8=8E=9C?= Date: Mon, 25 Aug 2025 20:24:43 +0800 Subject: [PATCH 36/76] fix ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 宁竞莜 --- .../test/mock/distributed_file_daemon_manager_mock.h | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/services/distributeddataservice/service/test/mock/distributed_file_daemon_manager_mock.h b/services/distributeddataservice/service/test/mock/distributed_file_daemon_manager_mock.h index cd68204fd..eee09b060 100644 --- a/services/distributeddataservice/service/test/mock/distributed_file_daemon_manager_mock.h +++ b/services/distributeddataservice/service/test/mock/distributed_file_daemon_manager_mock.h @@ -115,6 +115,18 @@ public: { return 0; } + int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr &listener) override + { + return 0; + } + int32_t UnregisterFileDfsListener(const std::string &instanceId) override + { + return 0; + } + int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) override + { + return 0; + } }; } // namespace DistributedFile } // namespace Storage -- Gitee From 7a097bf5bb38b5e4a6559083019883daa85e5546 Mon Sep 17 00:00:00 2001 From: gecheng Date: Mon, 25 Aug 2025 20:30:13 +0800 Subject: [PATCH 37/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../framework/screen/screen_manager.cpp | 2 + .../object/src/object_service_impl.cpp | 3 +- .../BUILD.gn | 4 +- .../objectserviceimp1_fuzzer}/corpus/init | 0 .../objectserviceimp1_fuzzer.cpp | 76 +++++++++++++++ .../objectserviceimp1_fuzzer.h} | 8 +- .../objectserviceimp1_fuzzer}/project.xml | 0 .../objectserviceimp2_fuzzer}/BUILD.gn | 37 ++++++-- .../corpus/init | 0 .../objectserviceimp2_fuzzer.cpp | 75 +++++++++++++++ .../objectserviceimp2_fuzzer.h} | 27 +----- .../project.xml | 0 .../objectserviceimp3_fuzzer/BUILD.gn | 74 +++++++++++++++ .../objectserviceimp3_fuzzer/corpus/init} | 7 +- .../objectserviceimp3_fuzzer.cpp} | 93 +------------------ .../objectserviceimp3_fuzzer.h | 21 +++++ .../objectserviceimp3_fuzzer/project.xml | 25 +++++ 17 files changed, 316 insertions(+), 136 deletions(-) rename services/distributeddataservice/service/test/fuzztest/{objectserviceimp_fuzzer => objectserviceimp1_fuzzer}/BUILD.gn (98%) rename services/distributeddataservice/{framework/test/fuzztest/screenmanager_fuzzer => service/test/fuzztest/objectserviceimp1_fuzzer}/corpus/init (100%) create mode 100644 services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.cpp rename services/distributeddataservice/service/test/fuzztest/{objectserviceimp_fuzzer/objectserviceimp_fuzzer.h => objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.h} (78%) rename services/distributeddataservice/{framework/test/fuzztest/screenmanager_fuzzer => service/test/fuzztest/objectserviceimp1_fuzzer}/project.xml (100%) rename services/distributeddataservice/{framework/test/fuzztest/screenmanager_fuzzer => service/test/fuzztest/objectserviceimp2_fuzzer}/BUILD.gn (56%) rename services/distributeddataservice/service/test/fuzztest/{objectserviceimp_fuzzer => objectserviceimp2_fuzzer}/corpus/init (100%) create mode 100644 services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp rename services/distributeddataservice/{framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.cpp => service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.h} (45%) rename services/distributeddataservice/service/test/fuzztest/{objectserviceimp_fuzzer => objectserviceimp2_fuzzer}/project.xml (100%) create mode 100644 services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn rename services/distributeddataservice/{framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.h => service/test/fuzztest/objectserviceimp3_fuzzer/corpus/init} (80%) rename services/distributeddataservice/service/test/fuzztest/{objectserviceimp_fuzzer/objectserviceimp_fuzzer.cpp => objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.cpp} (44%) create mode 100644 services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/project.xml diff --git a/services/distributeddataservice/framework/screen/screen_manager.cpp b/services/distributeddataservice/framework/screen/screen_manager.cpp index 6b939376e..1131fa821 100644 --- a/services/distributeddataservice/framework/screen/screen_manager.cpp +++ b/services/distributeddataservice/framework/screen/screen_manager.cpp @@ -39,6 +39,7 @@ bool ScreenManager::RegisterInstance(std::shared_ptr instance) return true; } +// LCOV_EXCL_START void ScreenManager::Subscribe(std::shared_ptr observer) { return; @@ -68,4 +69,5 @@ bool ScreenManager::IsLocked() { return false; } +// LCOV_EXCL_STOP } // namespace OHOS::DistributedData \ No newline at end of file diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index ff6d5ee3a..288d0dc43 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -414,6 +414,7 @@ ObjectServiceImpl::ObjectServiceImpl() EventCenter::GetInstance().Subscribe(BindEvent::BIND_SNAPSHOT, process); } +// LCOV_EXCL_START void ObjectServiceImpl::RegisterObjectServiceInfo() { DumpManager::Config serviceInfoConfig; @@ -431,7 +432,7 @@ void ObjectServiceImpl::RegisterHandler() }; DumpManager::GetInstance().AddHandler("FEATURE_INFO", uintptr_t(this), handler); } - +// LCOV_EXCL_STOP void ObjectServiceImpl::DumpObjectServiceInfo(int fd, std::map> ¶ms) { (void)params; diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn similarity index 98% rename from services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/BUILD.gn rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn index 039f0bf8e..989ef9128 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn @@ -24,7 +24,7 @@ ohos_fuzztest("ObjectServiceImpFuzzTest") { ] fuzz_config_file = - "${data_service_path}/service/test/fuzztest/objectserviceimp_fuzzer" + "${data_service_path}/service/test/fuzztest/objectserviceimp1_fuzzer" cflags = [ "-g", @@ -35,7 +35,7 @@ ohos_fuzztest("ObjectServiceImpFuzzTest") { ] sources = [ - "objectserviceimp_fuzzer.cpp", + "objectserviceimp1_fuzzer.cpp", ] deps = [ diff --git a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/corpus/init similarity index 100% rename from services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/corpus/init rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/corpus/init diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.cpp new file mode 100644 index 000000000..000754166 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2025 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. + */ + +#include + +#include "objectserviceimp1_fuzzer.h" +#include "object_service_impl.h" +#include "account/account_delegate.h" + +using namespace OHOS::DistributedObject; + +namespace OHOS { + +void ObjectStoreSaveFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + sptr callback; + std::string bundleName = provider.ConsumeRandomLengthString(100); + std::string sessionId = provider.ConsumeRandomLengthString(100); + std::string deviceId = provider.ConsumeRandomLengthString(100); + std::map> data; + std::vector remainingData = provider.ConsumeRemainingBytes(); + data["key1"] = remainingData; + objectServiceImpl->ObjectStoreSave(bundleName, sessionId, deviceId, data, callback); +} + +void OnUserChangeFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + uint32_t code = static_cast(AccountStatus::DEVICE_ACCOUNT_SWITCHED); + std::string user = provider.ConsumeRandomLengthString(100); + std::string account = provider.ConsumeRandomLengthString(100); + objectServiceImpl->OnUserChange(code, user, account); +} + +void ObjectStoreRevokeSaveFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + sptr callback; + std::string bundleName = provider.ConsumeRandomLengthString(100); + std::string sessionId = provider.ConsumeRandomLengthString(100); + objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); +} + +void ObjectStoreRetrieveFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + sptr callback; + std::string bundleName = provider.ConsumeRandomLengthString(100); + std::string sessionId = provider.ConsumeRandomLengthString(100); + objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::ObjectStoreSaveFuzzTest(provider); + OHOS::OnUserChangeFuzzTest(provider); + OHOS::ObjectStoreRevokeSaveFuzzTest(provider); + OHOS::ObjectStoreRetrieveFuzzTest(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.h similarity index 78% rename from services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.h rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.h index 8aa6bb0e2..9969aa5a5 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.h +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/objectserviceimp1_fuzzer.h @@ -13,9 +13,9 @@ * limitations under the License. */ -#ifndef OBJECT_SERVICE_IMP_FUZZER_H -#define OBJECT_SERVICE_IMP_FUZZER_H +#ifndef OBJECT_SERVICE_IMP1_FUZZER_H +#define OBJECT_SERVICE_IMP1_FUZZER_H -#define FUZZ_PROJECT_NAME "objectserviceimp_fuzzer" +#define FUZZ_PROJECT_NAME "objectserviceimp1_fuzzer" -#endif // OBJECT_SERVICE_IMP_FUZZER_H \ No newline at end of file +#endif // OBJECT_SERVICE_IMP1_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/project.xml similarity index 100% rename from services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/project.xml rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/project.xml diff --git a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn similarity index 56% rename from services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/BUILD.gn rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn index f063faa15..fe5037836 100644 --- a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn @@ -16,33 +16,52 @@ import("//build/test.gni") import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") ##############################fuzztest########################################## -ohos_fuzztest("ScreenManagerFuzzTest") { +ohos_fuzztest("ObjectServiceImpFuzzTest") { module_out_path = "datamgr_service/datamgr_service" include_dirs = [ - "${data_service_path}/framework/include", + "${data_service_path}/service/object/include", ] fuzz_config_file = - "${data_service_path}/framework/test/fuzztest/screenmanager_fuzzer" - - sources = [ "screenmanager_fuzzer.cpp" ] + "${data_service_path}/service/test/fuzztest/objectserviceimp2_fuzzer" cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "objectserviceimp2_fuzzer.cpp", ] deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/communicator:distributeddata_communicator", "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/object:distributeddata_object", ] external_deps = [ - "c_utils:utils", + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:dataobs_manager", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "data_object:data_object_inner", + "data_object:distributeddataobject_impl", + "device_manager:devicemanagersdk", + "dfs_service:distributed_file_daemon_kit_inner", + "dmsfwk:distributed_sdk", "hilog:libhilog", - "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", ] } @@ -50,6 +69,6 @@ ohos_fuzztest("ScreenManagerFuzzTest") { group("fuzztest") { testonly = true - deps = [ ":ScreenManagerFuzzTest" ] + deps = [ ":ObjectServiceImpFuzzTest" ] } -############################################################################### \ No newline at end of file +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/corpus/init similarity index 100% rename from services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/corpus/init rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/corpus/init diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp new file mode 100644 index 000000000..43c578288 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2025 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. + */ + +#include + +#include "objectserviceimp2_fuzzer.h" +#include "object_service_impl.h" +#include "account/account_delegate.h" + +using namespace OHOS::DistributedObject; + +namespace OHOS { + +void RegisterDataObserverFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + sptr callback; + std::string bundleName = provider.ConsumeRandomLengthString(100); + std::string sessionId = provider.ConsumeRandomLengthString(100); + objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); +} + +void OnAppUninstallFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + if (objectServiceImpl->factory_.staticActs_ == nullptr) { + return; + } + std::string bundleName = provider.ConsumeRandomLengthString(100); + int32_t user = provider.ConsumeIntegral(); + int32_t index = provider.ConsumeIntegral(); + objectServiceImpl->factory_.staticActs_->OnAppUninstall(bundleName, user, index); +} + +void ResolveAutoLaunchFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + std::string identifier = provider.ConsumeRandomLengthString(100); + DistributedDB::AutoLaunchParam param; + objectServiceImpl->ResolveAutoLaunch(identifier, param); +} + +void OnAppExitFuzzTest(FuzzedDataProvider &provider) +{ + std::shared_ptr objectServiceImpl = std::make_shared(); + pid_t uid = provider.ConsumeIntegral(); + pid_t pid = provider.ConsumeIntegral(); + uint32_t tokenId = provider.ConsumeIntegral(); + std::string bundleName = provider.ConsumeRandomLengthString(100); + objectServiceImpl->OnAppExit(uid, pid, tokenId, bundleName); +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::RegisterDataObserverFuzzTest(provider); + OHOS::OnAppUninstallFuzzTest(provider); + OHOS::ResolveAutoLaunchFuzzTest(provider); + OHOS::OnAppExitFuzzTest(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.h similarity index 45% rename from services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.cpp rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.h index d944f95c3..0e38d64c0 100644 --- a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.h @@ -13,28 +13,9 @@ * limitations under the License. */ -#include -#include "screenmanager_fuzzer.h" -#include "screen/screen_manager.h" +#ifndef OBJECT_SERVICE_IMP2_FUZZER_H +#define OBJECT_SERVICE_IMP2_FUZZER_H -using namespace OHOS::DistributedData; +#define FUZZ_PROJECT_NAME "objectserviceimp2_fuzzer" -namespace OHOS { -void TestScreenManager(FuzzedDataProvider &provider) -{ - ScreenManager::GetInstance()->Subscribe(nullptr); - ScreenManager::GetInstance()->Unsubscribe(nullptr); - ScreenManager::GetInstance()->BindExecutor(nullptr); - ScreenManager::GetInstance()->SubscribeScreenEvent(); - ScreenManager::GetInstance()->UnsubscribeScreenEvent(); -} - -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::TestScreenManager(provider); - return 0; -} \ No newline at end of file +#endif // OBJECT_SERVICE_IMP2_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/project.xml similarity index 100% rename from services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/project.xml rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn new file mode 100644 index 000000000..5a8871a0d --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn @@ -0,0 +1,74 @@ +# Copyright (c) 2025 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("ObjectServiceImpFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/object/include", + ] + + fuzz_config_file = + "${data_service_path}/service/test/fuzztest/objectserviceimp3_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ + "objectserviceimp3_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/communicator:distributeddata_communicator", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/object:distributeddata_object", + ] + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:dataobs_manager", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "data_object:data_object_inner", + "data_object:distributeddataobject_impl", + "device_manager:devicemanagersdk", + "dfs_service:distributed_file_daemon_kit_inner", + "dmsfwk:distributed_sdk", + "hilog:libhilog", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":ObjectServiceImpFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/corpus/init similarity index 80% rename from services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.h rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/corpus/init index ab2fe6fe3..7ade8a0fa 100644 --- a/services/distributeddataservice/framework/test/fuzztest/screenmanager_fuzzer/screenmanager_fuzzer.h +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/corpus/init @@ -13,9 +13,4 @@ * limitations under the License. */ -#ifndef SCREENMANAGER_FUZZER_H -#define SCREENMANAGER_FUZZER_H - -#define FUZZ_PROJECT_NAME "screenmanager_fuzzer" - -#endif // SCREENMANAGER_FUZZER_H +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.cpp similarity index 44% rename from services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.cpp rename to services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.cpp index de7adc4e9..fceecb58d 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp_fuzzer/objectserviceimp_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.cpp @@ -15,95 +15,14 @@ #include -#include "objectserviceimp_fuzzer.h" +#include "objectserviceimp3_fuzzer.h" #include "object_service_impl.h" #include "account/account_delegate.h" using namespace OHOS::DistributedObject; namespace OHOS { - -void ObjectStoreSaveFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - sptr callback; - std::string bundleName = provider.ConsumeRandomLengthString(100); - std::string sessionId = provider.ConsumeRandomLengthString(100); - std::string deviceId = provider.ConsumeRandomLengthString(100); - std::map> data; - std::vector remainingData = provider.ConsumeRemainingBytes(); - data["key1"] = remainingData; - objectServiceImpl->ObjectStoreSave(bundleName, sessionId, deviceId, data, callback); -} - -void OnUserChangeFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - uint32_t code = static_cast(AccountStatus::DEVICE_ACCOUNT_SWITCHED); - std::string user = provider.ConsumeRandomLengthString(100); - std::string account = provider.ConsumeRandomLengthString(100); - objectServiceImpl->OnUserChange(code, user, account); -} - -void ObjectStoreRevokeSaveFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - sptr callback; - std::string bundleName = provider.ConsumeRandomLengthString(100); - std::string sessionId = provider.ConsumeRandomLengthString(100); - objectServiceImpl->ObjectStoreRevokeSave(bundleName, sessionId, callback); -} - -void ObjectStoreRetrieveFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - sptr callback; - std::string bundleName = provider.ConsumeRandomLengthString(100); - std::string sessionId = provider.ConsumeRandomLengthString(100); - objectServiceImpl->ObjectStoreRetrieve(bundleName, sessionId, callback); -} - -void RegisterDataObserverFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - sptr callback; - std::string bundleName = provider.ConsumeRandomLengthString(100); - std::string sessionId = provider.ConsumeRandomLengthString(100); - objectServiceImpl->RegisterDataObserver(bundleName, sessionId, callback); -} - -void OnAppUninstallFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - if (objectServiceImpl->factory_.staticActs_ == nullptr) { - return; - } - std::string bundleName = provider.ConsumeRandomLengthString(100); - int32_t user = provider.ConsumeIntegral(); - int32_t index = provider.ConsumeIntegral(); - objectServiceImpl->factory_.staticActs_->OnAppUninstall(bundleName, user, index); -} - -void ResolveAutoLaunchFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - std::string identifier = provider.ConsumeRandomLengthString(100); - DistributedDB::AutoLaunchParam param; - objectServiceImpl->ResolveAutoLaunch(identifier, param); -} - -void OnAppExitFuzzTest(FuzzedDataProvider &provider) -{ - std::shared_ptr objectServiceImpl = std::make_shared(); - pid_t uid = provider.ConsumeIntegral(); - pid_t pid = provider.ConsumeIntegral(); - uint32_t tokenId = provider.ConsumeIntegral(); - std::string bundleName = provider.ConsumeRandomLengthString(100); - objectServiceImpl->OnAppExit(uid, pid, tokenId, bundleName); - objectServiceImpl->RegisterObjectServiceInfo(); - objectServiceImpl->RegisterHandler(); -} - + void DumpObjectServiceInfoFuzzTest(FuzzedDataProvider &provider) { std::shared_ptr objectServiceImpl = std::make_shared(); @@ -156,14 +75,6 @@ void BindAssetStoreFuzzTest(FuzzedDataProvider &provider) extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { FuzzedDataProvider provider(data, size); - OHOS::ObjectStoreSaveFuzzTest(provider); - OHOS::OnUserChangeFuzzTest(provider); - OHOS::ObjectStoreRevokeSaveFuzzTest(provider); - OHOS::ObjectStoreRetrieveFuzzTest(provider); - OHOS::RegisterDataObserverFuzzTest(provider); - OHOS::OnAppUninstallFuzzTest(provider); - OHOS::ResolveAutoLaunchFuzzTest(provider); - OHOS::OnAppExitFuzzTest(provider); OHOS::DumpObjectServiceInfoFuzzTest(provider); OHOS::SaveMetaDataFuzzTest(provider); OHOS::BindAssetStoreFuzzTest(provider); diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.h new file mode 100644 index 000000000..a68ec2fe1 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/objectserviceimp3_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 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. + */ + +#ifndef OBJECT_SERVICE_IMP3_FUZZER_H +#define OBJECT_SERVICE_IMP3_FUZZER_H + +#define FUZZ_PROJECT_NAME "objectserviceimp3_fuzzer" + +#endif // OBJECT_SERVICE_IMP3_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/project.xml new file mode 100644 index 000000000..a37a23b15 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 844b288d3fea5870099caabf3e451c6c68b4f6fd Mon Sep 17 00:00:00 2001 From: z30053452 Date: Mon, 25 Aug 2025 20:42:16 +0800 Subject: [PATCH 38/76] code fix Signed-off-by: z30053452 --- .../app/src/kvstore_data_service.cpp | 27 ++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index 51af0c61e..cb9b50d94 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -1160,7 +1160,14 @@ void KvStoreDataService::DumpStoreInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId }), metas, true)) { + std::vector users; + int32_t user = 0; + AccountDelegate::GetInstance()->QueryForegroundUsers(users); + if (users.size() > 0) { + user = users[0]; + } + if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), + metas, true)) { ZLOGE("get full meta failed"); return; } @@ -1314,7 +1321,14 @@ void KvStoreDataService::DumpUserInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId }), metas, true)) { + std::vector users; + int32_t user = 0; + AccountDelegate::GetInstance()->QueryForegroundUsers(users); + if (users.size() > 0) { + user = users[0]; + } + if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), + metas, true)) { ZLOGE("get full meta failed"); return; } @@ -1414,7 +1428,14 @@ void KvStoreDataService::DumpBundleInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId }), metas, true)) { + std::vector users; + int32_t user = 0; + AccountDelegate::GetInstance()->QueryForegroundUsers(users); + if (users.size() > 0) { + user = users[0]; + } + if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), + metas, true)) { ZLOGE("get full meta failed"); return; } -- Gitee From 9dd2e9b28446399e9547a030f789848accf3c84a Mon Sep 17 00:00:00 2001 From: z30053452 Date: Mon, 25 Aug 2025 21:12:27 +0800 Subject: [PATCH 39/76] code fix Signed-off-by: z30053452 --- .../app/src/kvstore_data_service.cpp | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index cb9b50d94..fa1a78012 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -1160,11 +1160,11 @@ void KvStoreDataService::DumpStoreInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - std::vector users; - int32_t user = 0; - AccountDelegate::GetInstance()->QueryForegroundUsers(users); - if (users.size() > 0) { - user = users[0]; + int user = 0; + auto ret = AccountDelegate::GetInstance()->QueryForegroundUserId(user); + if (!ret) { + ZLOGE("get foreground userid failed"); + return; } if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), metas, true)) { @@ -1321,11 +1321,11 @@ void KvStoreDataService::DumpUserInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - std::vector users; - int32_t user = 0; - AccountDelegate::GetInstance()->QueryForegroundUsers(users); - if (users.size() > 0) { - user = users[0]; + int user = 0; + auto ret = AccountDelegate::GetInstance()->QueryForegroundUserId(user); + if (!ret) { + ZLOGE("get foreground userid failed"); + return; } if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), metas, true)) { @@ -1428,11 +1428,11 @@ void KvStoreDataService::DumpBundleInfo(int fd, std::map metas; std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - std::vector users; - int32_t user = 0; - AccountDelegate::GetInstance()->QueryForegroundUsers(users); - if (users.size() > 0) { - user = users[0]; + int user = 0; + auto ret = AccountDelegate::GetInstance()->QueryForegroundUserId(user); + if (!ret) { + ZLOGE("get foreground userid failed"); + return; } if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), metas, true)) { -- Gitee From 21ff840153d95f46be502b8db1406aa639842507 Mon Sep 17 00:00:00 2001 From: gecheng Date: Mon, 25 Aug 2025 21:48:22 +0800 Subject: [PATCH 40/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../distributeddataservice/framework/test/fuzztest/BUILD.gn | 5 +---- .../service/object/src/object_service_impl.cpp | 1 + .../distributeddataservice/service/test/fuzztest/BUILD.gn | 4 +++- .../service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn | 4 ++-- .../service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn | 4 ++-- .../service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn | 4 ++-- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/services/distributeddataservice/framework/test/fuzztest/BUILD.gn b/services/distributeddataservice/framework/test/fuzztest/BUILD.gn index b35cb67af..e54fc7ba3 100644 --- a/services/distributeddataservice/framework/test/fuzztest/BUILD.gn +++ b/services/distributeddataservice/framework/test/fuzztest/BUILD.gn @@ -18,8 +18,5 @@ import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") group("fuzztest") { testonly = true - deps = [ - "storedebuginfo_fuzzer:fuzztest", - "screenmanager_fuzzer:fuzztest", - ] + deps = [ "storedebuginfo_fuzzer:fuzztest" ] } \ No newline at end of file diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index 288d0dc43..257502c07 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -433,6 +433,7 @@ void ObjectServiceImpl::RegisterHandler() DumpManager::GetInstance().AddHandler("FEATURE_INFO", uintptr_t(this), handler); } // LCOV_EXCL_STOP + void ObjectServiceImpl::DumpObjectServiceInfo(int fd, std::map> ¶ms) { (void)params; diff --git a/services/distributeddataservice/service/test/fuzztest/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/BUILD.gn index 107fde072..6dd680bdd 100644 --- a/services/distributeddataservice/service/test/fuzztest/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/BUILD.gn @@ -30,7 +30,9 @@ group("fuzztest") { if (datamgr_service_object) { deps += [ "objectservicestub_fuzzer:fuzztest", - "objectserviceimp_fuzzer:fuzztest", + "objectserviceimp1_fuzzer:fuzztest", + "objectserviceimp2_fuzzer:fuzztest", + "objectserviceimp3_fuzzer:fuzztest", "objectservicelistener_fuzzer:fuzztest", ] } diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn index 989ef9128..8d654ce30 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp1_fuzzer/BUILD.gn @@ -16,7 +16,7 @@ import("//build/test.gni") import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") ##############################fuzztest########################################## -ohos_fuzztest("ObjectServiceImpFuzzTest") { +ohos_fuzztest("ObjectServiceImp1FuzzTest") { module_out_path = "datamgr_service/datamgr_service" include_dirs = [ @@ -69,6 +69,6 @@ ohos_fuzztest("ObjectServiceImpFuzzTest") { group("fuzztest") { testonly = true - deps = [ ":ObjectServiceImpFuzzTest" ] + deps = [ ":ObjectServiceImp1FuzzTest" ] } ############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn index fe5037836..57ebaece8 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/BUILD.gn @@ -16,7 +16,7 @@ import("//build/test.gni") import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") ##############################fuzztest########################################## -ohos_fuzztest("ObjectServiceImpFuzzTest") { +ohos_fuzztest("ObjectServiceImp2FuzzTest") { module_out_path = "datamgr_service/datamgr_service" include_dirs = [ @@ -69,6 +69,6 @@ ohos_fuzztest("ObjectServiceImpFuzzTest") { group("fuzztest") { testonly = true - deps = [ ":ObjectServiceImpFuzzTest" ] + deps = [ ":ObjectServiceImp2FuzzTest" ] } ############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn index 5a8871a0d..46a6be379 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp3_fuzzer/BUILD.gn @@ -16,7 +16,7 @@ import("//build/test.gni") import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") ##############################fuzztest########################################## -ohos_fuzztest("ObjectServiceImpFuzzTest") { +ohos_fuzztest("ObjectServiceImp3FuzzTest") { module_out_path = "datamgr_service/datamgr_service" include_dirs = [ @@ -69,6 +69,6 @@ ohos_fuzztest("ObjectServiceImpFuzzTest") { group("fuzztest") { testonly = true - deps = [ ":ObjectServiceImpFuzzTest" ] + deps = [ ":ObjectServiceImp3FuzzTest" ] } ############################################################################### -- Gitee From da3d11a54c61fd509e0a49281ac0a36d2e34ded8 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Tue, 26 Aug 2025 10:04:54 +0800 Subject: [PATCH 41/76] fix: Signed-off-by: weishaoxiong --- .../service/test/cloud_service_impl_test.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp index 8f8c9f113..e66f7ad97 100644 --- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp @@ -1076,6 +1076,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) ASSERT_NE(cloudServiceImpl_, nullptr); auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); recoveryManager.OnNetworkDisconnected(); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); auto returnWithUserList = [](const std::vector &users) { return Invoke([=](std::vector &outUsers) -> bool { @@ -1089,14 +1090,16 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) .WillOnce(returnWithUserList({ MOCK_USER })) .WillOnce(Return(false)); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); - ASSERT_NE(recoveryManager.currentEvent_, nullptr); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); + recoveryManager.OnNetworkDisconnected(); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) .WillOnce(returnWithUserList({ MOCK_USER })) .WillOnce(returnWithUserList({})); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); - EXPECT_NE(recoveryManager.currentEvent_, nullptr); + EXPECT_EQ(recoveryManager.currentEvent_, nullptr); } /** -- Gitee From 91e4b6ed4640e296208930dd62d9a08cc9f74f63 Mon Sep 17 00:00:00 2001 From: z30053452 Date: Tue, 26 Aug 2025 14:47:55 +0800 Subject: [PATCH 42/76] code fix Signed-off-by: z30053452 --- .../app/src/kvstore_data_service.cpp | 40 ------------------- .../unittest/kvstore_data_service_test.cpp | 15 ------- .../service/dumper/src/dump_helper.cpp | 6 +-- 3 files changed, 3 insertions(+), 58 deletions(-) diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index fa1a78012..a9be1e0d0 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -364,10 +364,6 @@ void KvStoreDataService::OnStart() Handler handlerStoreInfo = std::bind(&KvStoreDataService::DumpStoreInfo, this, std::placeholders::_1, std::placeholders::_2); DumpManager::GetInstance().AddHandler("STORE_INFO", uintptr_t(this), handlerStoreInfo); - RegisterUserInfo(); - Handler handlerUserInfo = std::bind(&KvStoreDataService::DumpUserInfo, this, std::placeholders::_1, - std::placeholders::_2); - DumpManager::GetInstance().AddHandler("USER_INFO", uintptr_t(this), handlerUserInfo); RegisterBundleInfo(); Handler handlerBundleInfo = std::bind(&KvStoreDataService::DumpBundleInfo, this, std::placeholders::_1, std::placeholders::_2); @@ -1253,21 +1249,6 @@ std::string KvStoreDataService::GetIndentation(int size) return indentation; } -void KvStoreDataService::RegisterUserInfo() -{ - DumpManager::Config userInfoConfig; - userInfoConfig.fullCmd = "--user-info"; - userInfoConfig.abbrCmd = "-u"; - userInfoConfig.dumpName = "USER_INFO"; - userInfoConfig.countPrintf = PRINTF_COUNT_2; - userInfoConfig.infoName = " "; - userInfoConfig.minParamsNum = 0; - userInfoConfig.maxParamsNum = MAXIMUM_PARAMETER_LIMIT; // User contains no more than three parameters - userInfoConfig.childNode = "BUNDLE_INFO"; - userInfoConfig.dumpCaption = { "| Display all the user statistics", "| Display the user statistics by UserId" }; - DumpManager::GetInstance().AddConfig(userInfoConfig.dumpName, userInfoConfig); -} - void KvStoreDataService::BuildData(std::map &datas, const std::vector &metas) { for (auto &meta : metas) { @@ -1317,27 +1298,6 @@ void KvStoreDataService::PrintfInfo(int fd, const std::map> ¶ms) -{ - std::vector metas; - std::string localDeviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - int user = 0; - auto ret = AccountDelegate::GetInstance()->QueryForegroundUserId(user); - if (!ret) { - ZLOGE("get foreground userid failed"); - return; - } - if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ localDeviceId, std::to_string(user) }), - metas, true)) { - ZLOGE("get full meta failed"); - return; - } - FilterData(metas, params); - std::map datas; - BuildData(datas, metas); - PrintfInfo(fd, datas); -} - void KvStoreDataService::RegisterBundleInfo() { DumpManager::Config bundleInfoConfig; diff --git a/services/distributeddataservice/app/test/unittest/kvstore_data_service_test.cpp b/services/distributeddataservice/app/test/unittest/kvstore_data_service_test.cpp index fcaec7983..18167c5da 100644 --- a/services/distributeddataservice/app/test/unittest/kvstore_data_service_test.cpp +++ b/services/distributeddataservice/app/test/unittest/kvstore_data_service_test.cpp @@ -673,21 +673,6 @@ HWTEST_F(KvStoreDataServiceTest, BuildData002, TestSize.Level0) EXPECT_NO_FATAL_FAILURE(kvStoreDataServiceTest.BuildData(datas, metas)); } -/** -* @tc.name: DumpUserInfo001 -* @tc.desc: test DumpUserInfo function -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(KvStoreDataServiceTest, DumpUserInfo001, TestSize.Level0) -{ - KvStoreDataService kvStoreDataServiceTest; - int fd = 0; - std::map> params = {}; - EXPECT_NO_FATAL_FAILURE(kvStoreDataServiceTest.DumpUserInfo(fd, params)); -} - /** * @tc.name: DumpBundleInfo001 * @tc.desc: test DumpBundleInfo function diff --git a/services/distributeddataservice/service/dumper/src/dump_helper.cpp b/services/distributeddataservice/service/dumper/src/dump_helper.cpp index 04c125b06..287033dbd 100644 --- a/services/distributeddataservice/service/dumper/src/dump_helper.cpp +++ b/services/distributeddataservice/service/dumper/src/dump_helper.cpp @@ -264,9 +264,9 @@ void DumpHelper::DumpHelpInfo(int fd, std::map\nwhere possible options include:\n%s\nWhen -u/-u , -b/-b " - " or -s/-s is simultaneously selected,\nwe display the lowest level statistics where -u " - "> -b > -s\nand the statistics is filterd by the upper level options\n", + "Usage: hidumper -s 1301 -a \nwhere possible options include:\n%s\nWhen -b/-b " + " or -s/-s is simultaneously selected,\nwe display the lowest level statistics where " + "-b > -s\nand the statistics is filterd by the upper level options\n", info.c_str()); } -- Gitee From 6e1be6025f2e0beefe9600d57fcb9d7114031d22 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 14:51:59 +0800 Subject: [PATCH 43/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub2_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub2_fuzzer/corpus/init | 16 + .../cloudservicestub2_fuzzer/project.xml | 25 + 7 files changed, 1538 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 465fe4d472137685162ec795c36360b6d241e11d Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 14:54:38 +0800 Subject: [PATCH 44/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub2_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 460 ------------------ .../cloudservicestub2_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub2_fuzzer/corpus/init | 16 - .../cloudservicestub2_fuzzer/project.xml | 25 - 7 files changed, 1538 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 9993a96f8520aeb3a90a378c01a2686a948d95e7 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 14:57:44 +0800 Subject: [PATCH 45/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1538 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 8c23f025fa3c3d0eb1bb3550e2ae08bd805d8701 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 14:59:14 +0800 Subject: [PATCH 46/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 460 ------------------ .../cloudservicestub2_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1538 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 8b3e94a31183ea4d2b04bfd7c7092349057a38d5 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:01:33 +0800 Subject: [PATCH 47/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 460 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1538 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..b056cd107 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,460 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} + +int32_t CloudServiceImpl::OnInitialize() +{ + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + return E_OK; +} + +bool CloudServiceImpl::CleanWaterVersion(int32_t user) +{ + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + } + return true; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 2952f1634cf77bc3c122175c173ef1576edd865c Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:02:18 +0800 Subject: [PATCH 48/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 460 ------------------ .../cloudservicestub2_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.cpp | 460 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1538 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index b056cd107..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,460 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } - - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} - -int32_t CloudServiceImpl::OnInitialize() -{ - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - return E_OK; -} - -bool CloudServiceImpl::CleanWaterVersion(int32_t user) -{ - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - } - return true; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 8182c6acdf01c8a435725c6cfd8bdae04852c0ee Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:06:49 +0800 Subject: [PATCH 49/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub_fuzzer.cpp | 495 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 5 files changed, 653 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..f79d6ef60 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 5c44d31327a9c7ac612d3adbfb066c14890df857 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:07:49 +0800 Subject: [PATCH 50/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer.cpp | 495 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 495 ++++++++++++++++++ 2 files changed, 990 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..f79d6ef60 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..f79d6ef60 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file -- Gitee From 225126e4f604f135bcc0f56e9c371e2e4e14b430 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:08:50 +0800 Subject: [PATCH 51/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 495 ------------------ .../cloudservicestub2_fuzzer.cpp | 495 ------------------ .../cloudservicestub_fuzzer.cpp | 495 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1643 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index f79d6ef60..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index f79d6ef60..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index f79d6ef60..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 0281d9aa60912087c484157e5bef8b26993e0683 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:11:45 +0800 Subject: [PATCH 52/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub_fuzzer.cpp | 495 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + .../cloudservicestub2_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 472 +++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 495 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub2_fuzzer/corpus/init | 16 + .../cloudservicestub2_fuzzer/project.xml | 25 + 11 files changed, 1778 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..f79d6ef60 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..2c45cd78e --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,472 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..f79d6ef60 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + auto staticStores = CheckerManager::GetInstance().GetStaticStores(); + stores.insert(stores.end(), staticStores.begin(), staticStores.end()); + auto keys = cloudInfo.GetSchemaKey(); + for (const auto &[bundle, key] : keys) { + SchemaMeta schemaMeta; + if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && + schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { + bool found = std::any_of(stores.begin(), stores.end(), + [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { + return storeInfo.bundleName == schemaMeta.bundleName; + }); + if (!found) { + continue; + } + DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); + schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; + } + MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); + auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); + ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, + Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), + static_cast(lastSyncInfos.size())); + if (lastSyncInfos.empty()) { + return { ret, results }; + } + return { ret, AssembleLastResults(databases, lastSyncInfos) }; +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 631a1bc152bfd1bdfddb190a4931e25586987284 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:13:34 +0800 Subject: [PATCH 53/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer.cpp} | 0 .../cloudservicestub2_fuzzer.cpp} | 6 +- .../cloudservicestub2_fuzzer/BUILD.gn | 96 ------------------- .../cloudservicestub_fuzzer.h | 21 ---- .../cloudservicestub2_fuzzer/corpus/init | 16 ---- .../cloudservicestub2_fuzzer/project.xml | 25 ----- 6 files changed, 1 insertion(+), 163 deletions(-) rename services/distributeddataservice/service/test/fuzztest/{cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp => cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp} (100%) rename services/distributeddataservice/service/test/fuzztest/{cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp => cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp} (98%) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp similarity index 100% rename from services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.cpp rename to services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp similarity index 98% rename from services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp rename to services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp index 2c45cd78e..1bee9999f 100644 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub1_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -424,7 +424,7 @@ bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) return { INVALID_ARGUMENT, results }; } } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); std::vector users; Account::GetInstance()->QueryUsers(users); @@ -451,10 +451,6 @@ bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) if (status != SUCCESS) { return false; } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); } } // namespace OHOS diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub2_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 3bb21335d7a9766a7f0b396002bdab6971cab390 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:14:48 +0800 Subject: [PATCH 54/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 495 ------------------ .../cloudservicestub2_fuzzer.cpp | 468 ----------------- .../cloudservicestub_fuzzer.cpp | 495 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1616 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index f79d6ef60..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index f79d6ef60..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,495 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } - auto stores = CheckerManager::GetInstance().GetDynamicStores(); - auto staticStores = CheckerManager::GetInstance().GetStaticStores(); - stores.insert(stores.end(), staticStores.begin(), staticStores.end()); - auto keys = cloudInfo.GetSchemaKey(); - for (const auto &[bundle, key] : keys) { - SchemaMeta schemaMeta; - if (MetaDataManager::GetInstance().LoadMeta(key, schemaMeta, true) && - schemaMeta.metaVersion < SchemaMeta::CLEAN_WATER_VERSION) { - bool found = std::any_of(stores.begin(), stores.end(), - [&schemaMeta](const CheckerManager::StoreInfo &storeInfo) { - return storeInfo.bundleName == schemaMeta.bundleName; - }); - if (!found) { - continue; - } - DoClean(user, schemaMeta, GeneralStore::CleanMode::CLEAN_WATER); - schemaMeta.metaVersion = SchemaMeta::CLEAN_WATER_VERSION; - } - MetaDataManager::GetInstance().SaveMeta(key, schemaMeta, true); - auto [ret, lastSyncInfos] = syncManager_.QueryLastSyncInfo(queryKeys); - ZLOGI("code:%{public}d, id:%{public}s, bundleName:%{public}s, storeId:%{public}s, size:%{public}d", ret, - Anonymous::Change(id).c_str(), bundleName.c_str(), Anonymous::Change(storeId).c_str(), - static_cast(lastSyncInfos.size())); - if (lastSyncInfos.empty()) { - return { ret, results }; - } - return { ret, AssembleLastResults(databases, lastSyncInfos) }; -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 943f36f1734745695fbccd1fec743f7ed53e29ba Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:15:51 +0800 Subject: [PATCH 55/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1562 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From a089eb148218b8d659e9934a675aadd93dc9bf60 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:16:43 +0800 Subject: [PATCH 56/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 468 ------------------ .../cloudservicestub2_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1562 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 9fc18d1dc5c4d6965196dc523f96d4ac2336611e Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:18:03 +0800 Subject: [PATCH 57/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1562 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 8a7786645f1b6849fb2662d85565c48b9ea092a2 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:18:22 +0800 Subject: [PATCH 58/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 468 ------------------ .../cloudservicestub2_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1562 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 76cf0bebca45428f91b774478ccf70c70e201960 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:19:19 +0800 Subject: [PATCH 59/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1562 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From 6b458ccbcdf27e1a35e179cb875647902caed0b1 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:19:33 +0800 Subject: [PATCH 60/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 468 ------------------ .../cloudservicestub2_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1562 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 00fab3a61c7dd06dec54e90ebb0d234cecbc3e42 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:44:24 +0800 Subject: [PATCH 61/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ++++ .../cloudservicestub1_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub2_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.cpp | 468 ++++++++++++++++++ .../cloudservicestub_fuzzer.h | 21 + .../cloudservicestub1_fuzzer/corpus/init | 16 + .../cloudservicestub1_fuzzer/project.xml | 25 + 7 files changed, 1562 insertions(+) create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init create mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn new file mode 100644 index 000000000..2618103ac --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn @@ -0,0 +1,96 @@ +# Copyright (c) 2023 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. +##############################hydra-fuzz######################################## +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") + +##############################fuzztest########################################## +ohos_fuzztest("CloudServiceStubFuzzTest") { + module_out_path = "datamgr_service/datamgr_service" + + include_dirs = [ + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/network", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/adapter/include/communicator", + ] + + fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ + "${data_service_path}/app/src/checker/bundle_checker.cpp", + "${data_service_path}/app/src/checker/system_checker.cpp", + "cloudservicestub_fuzzer.cpp", + ] + + deps = [ + "${data_service_path}/adapter/account:distributeddata_account", + "${data_service_path}/adapter/dfx:distributeddata_dfx", + "${data_service_path}/adapter/network:distributeddata_network", + "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", + "${data_service_path}/adapter/utils:distributeddata_utils", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${data_service_path}/service/bootstrap:distributeddata_bootstrap", + "${data_service_path}/service/cloud:distributeddata_cloud", + "${data_service_path}/service/common:distributeddata_common", + "${data_service_path}/service/rdb:distributeddata_rdb", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtoken_setproc", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "hicollie:libhicollie", + "hilog:libhilog", + "hisysevent:libhisysevent", + "huks:libhukssdk", + "ipc:ipc_core", + "kv_store:datamgr_common", + "kv_store:distributeddata_inner", + "kv_store:distributeddata_mgr", + "kv_store:distributeddb", + "relational_store:native_rdb", + "resource_management:global_resmgr", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":CloudServiceStubFuzzTest" ] +} +############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp new file mode 100644 index 000000000..1bee9999f --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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. + */ + +#include + +#include "cloudservicestub_fuzzer.h" + +#include +#include + +#include "accesstoken_kit.h" +#include "cloud_service_impl.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "securec.h" +#include "token_setproc.h" + +using namespace OHOS::CloudData; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +constexpr int USER_ID = 100; +constexpr int INST_INDEX = 0; +const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; +constexpr uint32_t CODE_MIN = 0; +constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; +constexpr size_t NUM_MIN = 5; +constexpr size_t NUM_MAX = 12; + +void AllocAndSetHapToken() +{ + HapInfoParams info = { + .userID = USER_ID, + .bundleName = "ohos.test.demo", + .instIndex = INST_INDEX, + .appIDDesc = "ohos.test.demo", + .isSystemApp = true + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = { + { + .permissionName = "ohos.permission.CLOUDDATA_CONFIG", + .isGeneral = true, + .resDeviceID = { "local" }, + .grantStatus = { PermissionState::PERMISSION_GRANTED }, + .grantFlags = { 1 } + } + } + }; + auto tokenID = AccessTokenKit::AllocHapToken(info, policy); + SetSelfTokenID(tokenID.tokenIDEx); +} + +bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnRemoteRequest(code, request, reply); + return true; +} + +bool OnEnableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnEnableCloud(code, request, reply); + XCollie xcollie( + __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); + return status; + } + cloudInfo.enableCloud = true; + for (const auto &[bundle, value] : switches) { + if (!cloudInfo.Exist(bundle)) { + continue; + } + cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); + ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); + } + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); + return true; +} + +bool OnDisableCloudFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnDisableCloud(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), + Anonymous::Change(cloudInfo.id).c_str()); + return INVALID_ARGUMENT; + } + cloudInfo.enableCloud = false; + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + StoreMetaMapping meta(storeInfo); + meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; + if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && + !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { + ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); + if (store == nullptr) { + ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); + return { GeneralError::E_ERROR, nullptr }; + } + return store->PreSharing(query); + Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); + ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); + return true; +} + +bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnChangeAppSwitch(code, request, reply); + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + CloudSyncScene scene; + if (appSwitch == SWITCH_ON) { + scene = CloudSyncScene::SWITCH_ON; + } else { + scene = CloudSyncScene::SWITCH_OFF; + } + std::lock_guard lock(rwMetaMutex_); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS || !cloudInfo.enableCloud) { + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret = " + std::to_string(status)); + return status; + } + if (cloudInfo.id != id) { + ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, + WORK_DO_CLOUD_SYNC })); + return INVALID_ARGUMENT; + } + if (!cloudInfo.Exist(bundleName)) { + std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); + if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { + ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," + "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, + Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); + Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, + "ChangeAppSwitch ret=" + std::to_string(status)); + return INVALID_ARGUMENT; + } + ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); + } + cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); + if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { + return ERROR; + } + Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); + if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { + SyncManager::SyncInfo info(cloudInfo.user, bundleName); + syncManager_.DoCloudSync(info); + } + ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), + bundleName.c_str(), appSwitch); + return true; +} + +bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnNotifyDataChange(code, request, reply); + auto tokenId = IPCSkeleton::GetCallingTokenID(); + auto user = Account::GetInstance()->GetUserByToken(tokenId); + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { + return INVALID_ARGUMENT; + } + XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + ExtraData exData; + if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { + ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), + userId, extraData.empty() ? "empty" : "not empty"); + return INVALID_ARGUMENT; + } + std::vector users; + if (userId != INVALID_USER_ID) { + users.emplace_back(userId); + } else { + Account::GetInstance()->QueryForegroundUsers(users); + } + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + auto &bundleName = exData.info.bundleName; + auto &prepareTraceId = exData.info.context.prepareTraceId; + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { + ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); + SchemaMeta schemaMeta; + if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { + ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); + if (dbInfos.empty()) { + ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); + syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); + return INVALID_ARGUMENT; + } + for (const auto &dbInfo : dbInfos) { + syncManager_.DoCloudSync(SyncManager::SyncInfo( + { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); + } + } + auto [status, cloudInfo] = GetCloudInfoFromServer(user); + if (status != SUCCESS) { + ZLOGE("user:%{public}d, status:%{public}d", user, status); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); + return false; + } + ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", + Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); + CloudInfo oldInfo; + if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + return true; + } + MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); + if (oldInfo.id != cloudInfo.id) { + ReleaseUserInfo(user, scene); + ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), + Anonymous::Change(oldInfo.id).c_str()); + MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); + std::map actions; + for (auto &[bundle, app] : cloudInfo.apps) { + MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); + actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; + } + DoClean(oldInfo, actions); + Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", + "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); + } + return true; +} + +bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) +{ + static std::shared_ptr cloudServiceImpl = std::make_shared(); + static std::once_flag onceFlag; + std::call_once(onceFlag, [&]() { + std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); + cloudServiceImpl->OnBind( + { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); + AllocAndSetHapToken(); + }); + + uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); + std::vector remainingData = provider.ConsumeRemainingBytes(); + MessageParcel request; + request.WriteInterfaceToken(INTERFACE_TOKEN); + request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); + request.RewindRead(0); + MessageParcel reply; + std::shared_ptr cloudServiceStub = cloudServiceImpl; + cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); + QueryLastResults results; + auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); + auto [status, cloudInfo] = GetCloudInfo(user); + if (status != SUCCESS) { + Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, + "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); + return { ERROR, results }; + } + if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { + ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); + return { INVALID_ARGUMENT, results }; + } + std::vector schemas; + auto key = cloudInfo.GetSchemaPrefix(bundleName); + if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { + return { ERROR, results }; + } + + std::vector queryKeys; + std::vector databases; + for (const auto &schema : schemas) { + if (schema.bundleName != bundleName) { + continue; + } + databases = schema.databases; + for (const auto &database : schema.databases) { + if (storeId.empty() || database.alias == storeId) { + queryKeys.push_back({ user, id, bundleName, database.name }); + } + } + if (queryKeys.empty()) { + ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); + return { INVALID_ARGUMENT, results }; + } + } +XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); + DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); + std::vector users; + Account::GetInstance()->QueryUsers(users); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + CleanWaterVersion(user); + } + Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, + { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); + for (auto user : users) { + if (user == DEFAULT_USER) { + continue; + } + Subscription sub; + sub.userId = user; + if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { + continue; + } + InitSubTask(sub); + } + auto [status, cloudInfo] = GetCloudInfoFromMeta(user); + if (status != SUCCESS) { + return false; + } +} +} // namespace OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteRequestFuzz(provider); + OHOS::OnEnableCloudFuzz(provider); + OHOS::OnDisableCloudFuzz(provider); + OHOS::OnChangeAppSwitchFuzz(provider); + OHOS::OnNotifyDataChangeFuzz(provider); + OHOS::OnQueryLastSyncInfoFuzz(provider); + return 0; +} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h new file mode 100644 index 000000000..c007ebba5 --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2023 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. + */ + +#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H +#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H + +#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" + +#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init new file mode 100644 index 000000000..2b595da0c --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2023 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. + */ + +FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml new file mode 100644 index 000000000..3fdba3e8b --- /dev/null +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file -- Gitee From efefd1082cfb5eb5854b61a361865c3f54438aa8 Mon Sep 17 00:00:00 2001 From: gecheng Date: Tue, 26 Aug 2025 15:46:08 +0800 Subject: [PATCH 62/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../cloudservicestub1_fuzzer/BUILD.gn | 96 ---- .../cloudservicestub1_fuzzer.cpp | 468 ------------------ .../cloudservicestub2_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.cpp | 468 ------------------ .../cloudservicestub_fuzzer.h | 21 - .../cloudservicestub1_fuzzer/corpus/init | 16 - .../cloudservicestub1_fuzzer/project.xml | 25 - 7 files changed, 1562 deletions(-) delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init delete mode 100644 services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn deleted file mode 100644 index 2618103ac..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/BUILD.gn +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright (c) 2023 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. -##############################hydra-fuzz######################################## -import("//build/config/features.gni") -import("//build/test.gni") -import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni") - -##############################fuzztest########################################## -ohos_fuzztest("CloudServiceStubFuzzTest") { - module_out_path = "datamgr_service/datamgr_service" - - include_dirs = [ - "${data_service_path}/service/cloud", - "${data_service_path}/service/common", - "${data_service_path}/service/config/include", - "${data_service_path}/service/crypto/include", - "${data_service_path}/service/kvdb", - "${data_service_path}/service/matrix/include", - "${data_service_path}/service/network", - "${data_service_path}/service/object", - "${data_service_path}/service/permission/include", - "${data_service_path}/service/rdb", - "${data_service_path}/adapter/include/communicator", - ] - - fuzz_config_file = "${data_service_path}/service/test/fuzztest/cloudservicestub_fuzzer" - - cflags = [ - "-g", - "-O0", - "-Wno-unused-variable", - "-fno-omit-frame-pointer", - ] - - sources = [ - "${data_service_path}/app/src/checker/bundle_checker.cpp", - "${data_service_path}/app/src/checker/system_checker.cpp", - "cloudservicestub_fuzzer.cpp", - ] - - deps = [ - "${data_service_path}/adapter/account:distributeddata_account", - "${data_service_path}/adapter/dfx:distributeddata_dfx", - "${data_service_path}/adapter/network:distributeddata_network", - "${data_service_path}/adapter/schema_helper:distributeddata_schema_helper", - "${data_service_path}/adapter/utils:distributeddata_utils", - "${data_service_path}/framework:distributeddatasvcfwk", - "${data_service_path}/service:distributeddatasvc", - "${data_service_path}/service/bootstrap:distributeddata_bootstrap", - "${data_service_path}/service/cloud:distributeddata_cloud", - "${data_service_path}/service/common:distributeddata_common", - "${data_service_path}/service/rdb:distributeddata_rdb", - ] - - external_deps = [ - "access_token:libaccesstoken_sdk", - "access_token:libtoken_setproc", - "access_token:libtokenid_sdk", - "bundle_framework:appexecfwk_base", - "bundle_framework:appexecfwk_core", - "c_utils:utils", - "device_auth:deviceauth_sdk", - "device_manager:devicemanagersdk", - "hicollie:libhicollie", - "hilog:libhilog", - "hisysevent:libhisysevent", - "huks:libhukssdk", - "ipc:ipc_core", - "kv_store:datamgr_common", - "kv_store:distributeddata_inner", - "kv_store:distributeddata_mgr", - "kv_store:distributeddb", - "relational_store:native_rdb", - "resource_management:global_resmgr", - "safwk:system_ability_fwk", - "samgr:samgr_proxy", - ] -} - -############################################################################### -group("fuzztest") { - testonly = true - - deps = [ ":CloudServiceStubFuzzTest" ] -} -############################################################################### diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub1_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub2_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp deleted file mode 100644 index 1bee9999f..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.cpp +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#include - -#include "cloudservicestub_fuzzer.h" - -#include -#include - -#include "accesstoken_kit.h" -#include "cloud_service_impl.h" -#include "ipc_skeleton.h" -#include "message_parcel.h" -#include "securec.h" -#include "token_setproc.h" - -using namespace OHOS::CloudData; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -constexpr int USER_ID = 100; -constexpr int INST_INDEX = 0; -const std::u16string INTERFACE_TOKEN = u"OHOS.CloudData.CloudServer"; -constexpr uint32_t CODE_MIN = 0; -constexpr uint32_t CODE_MAX = CloudService::TransId::TRANS_BUTT + 1; -constexpr size_t NUM_MIN = 5; -constexpr size_t NUM_MAX = 12; - -void AllocAndSetHapToken() -{ - HapInfoParams info = { - .userID = USER_ID, - .bundleName = "ohos.test.demo", - .instIndex = INST_INDEX, - .appIDDesc = "ohos.test.demo", - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = { - { - .permissionName = "ohos.permission.CLOUDDATA_CONFIG", - .isGeneral = true, - .resDeviceID = { "local" }, - .grantStatus = { PermissionState::PERMISSION_GRANTED }, - .grantFlags = { 1 } - } - } - }; - auto tokenID = AccessTokenKit::AllocHapToken(info, policy); - SetSelfTokenID(tokenID.tokenIDEx); -} - -bool OnRemoteRequestFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnRemoteRequest(code, request, reply); - return true; -} - -bool OnEnableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnEnableCloud(code, request, reply); - XCollie xcollie( - __FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY, RESTART_SERVICE_TIME_THRESHOLD); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_ENABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "EnableCloud ret=" + std::to_string(status)); - return status; - } - cloudInfo.enableCloud = true; - for (const auto &[bundle, value] : switches) { - if (!cloudInfo.Exist(bundle)) { - continue; - } - cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON); - ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value); - } - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::ENABLE_CLOUD, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size()); - return true; -} - -bool OnDisableCloudFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnDisableCloud(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - ReleaseUserInfo(user, CloudSyncScene::DISABLE_CLOUD); - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_DISABLE_CLOUD, Fault::CSF_CLOUD_INFO, "", "DisableCloud ret=" + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s", Anonymous::Change(id).c_str(), - Anonymous::Change(cloudInfo.id).c_str()); - return INVALID_ARGUMENT; - } - cloudInfo.enableCloud = false; - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - StoreMetaMapping meta(storeInfo); - meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid; - if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - ZLOGE("failed, no store mapping bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - if (!meta.cloudPath.empty() && meta.dataDir != meta.cloudPath && - !MetaDataManager::GetInstance().LoadMeta(meta.GetCloudStoreMetaKey(), meta, true)) { - ZLOGE("failed, no store meta bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(), - meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - auto [status, store] = SyncManager::GetStore(meta, storeInfo.user, true); - if (store == nullptr) { - ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str()); - return { GeneralError::E_ERROR, nullptr }; - } - return store->PreSharing(query); - Execute(GenTask(0, cloudInfo.user, CloudSyncScene::DISABLE_CLOUD, { WORK_STOP_CLOUD_SYNC, WORK_SUB })); - ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str()); - return true; -} - -bool OnChangeAppSwitchFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnChangeAppSwitch(code, request, reply); - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - CloudSyncScene scene; - if (appSwitch == SWITCH_ON) { - scene = CloudSyncScene::SWITCH_ON; - } else { - scene = CloudSyncScene::SWITCH_OFF; - } - std::lock_guard lock(rwMetaMutex_); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS || !cloudInfo.enableCloud) { - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret = " + std::to_string(status)); - return status; - } - if (cloudInfo.id != id) { - ZLOGW("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s", - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB, - WORK_DO_CLOUD_SYNC })); - return INVALID_ARGUMENT; - } - if (!cloudInfo.Exist(bundleName)) { - std::tie(status, cloudInfo) = GetCloudInfoFromServer(user); - if (status != SUCCESS || !cloudInfo.enableCloud || cloudInfo.id != id || !cloudInfo.Exist(bundleName)) { - ZLOGE("invalid args, status:%{public}d, enableCloud:%{public}d, [input] id:%{public}s," - "[exist] id:%{public}s, bundleName:%{public}s", status, cloudInfo.enableCloud, - Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str()); - Report(appSwitch == SWITCH_ON ? FT_SWITCH_ON : FT_SWITCH_OFF, Fault::CSF_CLOUD_INFO, bundleName, - "ChangeAppSwitch ret=" + std::to_string(status)); - return INVALID_ARGUMENT; - } - ZLOGI("add app switch, bundleName:%{public}s", bundleName.c_str()); - } - cloudInfo.apps[bundleName].cloudSwitch = (appSwitch == SWITCH_ON); - if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) { - return ERROR; - } - Execute(GenTask(0, cloudInfo.user, scene, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); - if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) { - SyncManager::SyncInfo info(cloudInfo.user, bundleName); - syncManager_.DoCloudSync(info); - } - ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(), - bundleName.c_str(), appSwitch); - return true; -} - -bool OnNotifyDataChangeFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnNotifyDataChange(code, request, reply); - auto tokenId = IPCSkeleton::GetCallingTokenID(); - auto user = Account::GetInstance()->GetUserByToken(tokenId); - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(id, bundleName, cloudInfo) != E_OK) { - return INVALID_ARGUMENT; - } - XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - ExtraData exData; - if (eventId != DATA_CHANGE_EVENT_ID || extraData.empty() || !exData.Unmarshall(extraData)) { - ZLOGE("invalid args, eventId:%{public}s, user:%{public}d, extraData is %{public}s", eventId.c_str(), - userId, extraData.empty() ? "empty" : "not empty"); - return INVALID_ARGUMENT; - } - std::vector users; - if (userId != INVALID_USER_ID) { - users.emplace_back(userId); - } else { - Account::GetInstance()->QueryForegroundUsers(users); - } - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - auto &bundleName = exData.info.bundleName; - auto &prepareTraceId = exData.info.context.prepareTraceId; - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (CheckNotifyConditions(exData.info.accountId, bundleName, cloudInfo) != E_OK) { - ZLOGD("invalid user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto schemaKey = CloudInfo::GetSchemaKey(user, bundleName); - SchemaMeta schemaMeta; - if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) { - ZLOGE("no exist meta, user:%{public}d, traceId:%{public}s", user, prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - auto dbInfos = GetDbInfoFromExtraData(exData, schemaMeta); - if (dbInfos.empty()) { - ZLOGE("GetDbInfoFromExtraData failed, empty database info. traceId:%{public}s.", prepareTraceId.c_str()); - syncManager_.Report({ user, bundleName, prepareTraceId, SyncStage::END, INVALID_ARGUMENT }); - return INVALID_ARGUMENT; - } - for (const auto &dbInfo : dbInfos) { - syncManager_.DoCloudSync(SyncManager::SyncInfo( - { cloudInfo.user, bundleName, dbInfo.first, dbInfo.second, MODE_PUSH, prepareTraceId })); - } - } - auto [status, cloudInfo] = GetCloudInfoFromServer(user); - if (status != SUCCESS) { - ZLOGE("user:%{public}d, status:%{public}d", user, status); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", "UpdateCloudInfo ret=" + std::to_string(status)); - return false; - } - ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu", - Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size()); - CloudInfo oldInfo; - if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) { - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - return true; - } - MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - if (oldInfo.id != cloudInfo.id) { - ReleaseUserInfo(user, scene); - ZLOGE("different id, [server] id:%{public}s, [meta] id:%{public}s", Anonymous::Change(cloudInfo.id).c_str(), - Anonymous::Change(oldInfo.id).c_str()); - MetaDataManager::GetInstance().DelMeta(Subscription::GetKey(user), true); - std::map actions; - for (auto &[bundle, app] : cloudInfo.apps) { - MetaDataManager::GetInstance().DelMeta(Subscription::GetRelationKey(user, bundle), true); - actions[bundle] = GeneralStore::CleanMode::CLOUD_INFO; - } - DoClean(oldInfo, actions); - Report(GetDfxFaultType(scene), Fault::CSF_CLOUD_INFO, "", - "Clean: different id, new:" + Anonymous::Change(cloudInfo.id) + ", old:" + Anonymous::Change(oldInfo.id)); - } - return true; -} - -bool OnQueryLastSyncInfoFuzz(FuzzedDataProvider &provider) -{ - static std::shared_ptr cloudServiceImpl = std::make_shared(); - static std::once_flag onceFlag; - std::call_once(onceFlag, [&]() { - std::shared_ptr executor = std::make_shared(NUM_MAX, NUM_MIN); - cloudServiceImpl->OnBind( - { "CloudServiceStubFuzz", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); - AllocAndSetHapToken(); - }); - - uint32_t code = provider.ConsumeIntegralInRange(CODE_MIN, CODE_MAX); - std::vector remainingData = provider.ConsumeRemainingBytes(); - MessageParcel request; - request.WriteInterfaceToken(INTERFACE_TOKEN); - request.WriteBuffer(static_cast(remainingData.data()), remainingData.size()); - request.RewindRead(0); - MessageParcel reply; - std::shared_ptr cloudServiceStub = cloudServiceImpl; - cloudServiceStub->OnQueryLastSyncInfo(code, request, reply); - QueryLastResults results; - auto user = Account::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID()); - auto [status, cloudInfo] = GetCloudInfo(user); - if (status != SUCCESS) { - Report(FT_QUERY_INFO, Fault::CSF_CLOUD_INFO, bundleName, - "QueryLastSyncInfo ret=" + std::to_string(status) + ",storeId=" + storeId); - return { ERROR, results }; - } - if (cloudInfo.apps.find(bundleName) == cloudInfo.apps.end()) { - ZLOGE("Invalid bundleName: %{public}s", bundleName.c_str()); - return { INVALID_ARGUMENT, results }; - } - std::vector schemas; - auto key = cloudInfo.GetSchemaPrefix(bundleName); - if (!MetaDataManager::GetInstance().LoadMeta(key, schemas, true) || schemas.empty()) { - return { ERROR, results }; - } - - std::vector queryKeys; - std::vector databases; - for (const auto &schema : schemas) { - if (schema.bundleName != bundleName) { - continue; - } - databases = schema.databases; - for (const auto &database : schema.databases) { - if (storeId.empty() || database.alias == storeId) { - queryKeys.push_back({ user, id, bundleName, database.name }); - } - } - if (queryKeys.empty()) { - ZLOGE("Invalid storeId: %{public}s", Anonymous::Change(storeId).c_str()); - return { INVALID_ARGUMENT, results }; - } - } -XCollie xcollie(__FUNCTION__, XCollie::XCOLLIE_LOG | XCollie::XCOLLIE_RECOVERY); - DistributedDB::RuntimeConfig::SetCloudTranslate(std::make_shared()); - std::vector users; - Account::GetInstance()->QueryUsers(users); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - CleanWaterVersion(user); - } - Execute(GenTask(0, 0, CloudSyncScene::SERVICE_INIT, - { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB })); - for (auto user : users) { - if (user == DEFAULT_USER) { - continue; - } - Subscription sub; - sub.userId = user; - if (!MetaDataManager::GetInstance().LoadMeta(sub.GetKey(), sub, true)) { - continue; - } - InitSubTask(sub); - } - auto [status, cloudInfo] = GetCloudInfoFromMeta(user); - if (status != SUCCESS) { - return false; - } -} -} // namespace OHOS - -/* Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) -{ - FuzzedDataProvider provider(data, size); - OHOS::OnRemoteRequestFuzz(provider); - OHOS::OnEnableCloudFuzz(provider); - OHOS::OnDisableCloudFuzz(provider); - OHOS::OnChangeAppSwitchFuzz(provider); - OHOS::OnNotifyDataChangeFuzz(provider); - OHOS::OnQueryLastSyncInfoFuzz(provider); - return 0; -} \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h deleted file mode 100644 index c007ebba5..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/cloudservicestub_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -#ifndef DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H -#define DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H - -#define FUZZ_PROJECT_NAME "cloudservicestub_fuzzer" - -#endif // DATAMGR_SERVICE_CLOUD_SERVICE_STUB_FUZZER_H \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init deleted file mode 100644 index 2b595da0c..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/corpus/init +++ /dev/null @@ -1,16 +0,0 @@ -/* - * Copyright (c) 2023 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. - */ - -FUZZ \ No newline at end of file diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml b/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml deleted file mode 100644 index 3fdba3e8b..000000000 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub1_fuzzer/project.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - - - 1000 - - 300 - - 4096 - - \ No newline at end of file -- Gitee From 488342d6919ca540440eb5b481142ef37f73598a Mon Sep 17 00:00:00 2001 From: wanxiaoqing Date: Tue, 26 Aug 2025 18:39:32 +0800 Subject: [PATCH 63/76] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E5=B7=AE=E5=BC=82?= =?UTF-8?q?=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wanxiaoqing --- .../test/udmf_preprocess_utils_mock_test.cpp | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp index b09a55fff..437bca9d4 100644 --- a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp +++ b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp @@ -16,6 +16,7 @@ #include "preprocess_utils.h" #include "gtest/gtest.h" #include "access_token_mock.h" +#include "ipc_skeleton.h" namespace OHOS::UDMF { using namespace testing; @@ -129,4 +130,44 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId003, TestSi bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName); EXPECT_EQ(ret, true); } + +/** +* @tc.name: GetAlterableBundleNameByTokenId004 +* @tc.desc: Abnormal test of GetSpecificBundleNameByTokenId for native +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId004, TestSize.Level1) +{ + uint32_t tokenId = 999; + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_NATIVE)); + EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); + std::string bundleName = ""; + std::string specificBundleName = ""; + PreProcessUtils preProcessUtils; + bool ret = preProcessUtils.GetSpecificBundleNameByTokenId(tokenId, specificBundleName, bundleName); + EXPECT_EQ(ret, false); +} + +/** +* @tc.name: FillRuntimeInfo001 +* @tc.desc: Normal test of FillRuntimeInfo +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(UdmfPreProcessUtilsMockTest, FillRuntimeInfo001, TestSize.Level1) +{ + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillRepeatedly(Return(TOKEN_NATIVE)); + EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillRepeatedly(Return(RET_SUCCESS)); + + UnifiedData data; + CustomOption option; + option.intention = UD_INTENTION_DATA_HUB; + option.tokenId = static_cast(IPCSkeleton::GetCallingTokenID()); + PreProcessUtils preProcessUtils; + auto ret = preProcessUtils.FillRuntimeInfo(data, option); + EXPECT_EQ(ret, E_OK); +} }; // namespace UDMF \ No newline at end of file -- Gitee From f65f483b635a9121ac23bb30509c60832a4e1ebd Mon Sep 17 00:00:00 2001 From: gecheng Date: Wed, 27 Aug 2025 11:03:28 +0800 Subject: [PATCH 64/76] =?UTF-8?q?=E5=8D=95=E4=B8=AAFUZZ=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=A4=AA=E5=A4=9Aapi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: gecheng --- .../framework/screen/screen_manager.cpp | 3 +-- .../service/object/src/object_service_impl.cpp | 6 ++++-- .../objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp | 3 --- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/services/distributeddataservice/framework/screen/screen_manager.cpp b/services/distributeddataservice/framework/screen/screen_manager.cpp index 1131fa821..c2f7d5d3a 100644 --- a/services/distributeddataservice/framework/screen/screen_manager.cpp +++ b/services/distributeddataservice/framework/screen/screen_manager.cpp @@ -64,10 +64,9 @@ void ScreenManager::UnsubscribeScreenEvent() { return; } - +// LCOV_EXCL_STOP bool ScreenManager::IsLocked() { return false; } -// LCOV_EXCL_STOP } // namespace OHOS::DistributedData \ No newline at end of file diff --git a/services/distributeddataservice/service/object/src/object_service_impl.cpp b/services/distributeddataservice/service/object/src/object_service_impl.cpp index 257502c07..12346d892 100644 --- a/services/distributeddataservice/service/object/src/object_service_impl.cpp +++ b/services/distributeddataservice/service/object/src/object_service_impl.cpp @@ -414,25 +414,27 @@ ObjectServiceImpl::ObjectServiceImpl() EventCenter::GetInstance().Subscribe(BindEvent::BIND_SNAPSHOT, process); } -// LCOV_EXCL_START void ObjectServiceImpl::RegisterObjectServiceInfo() { + // LCOV_EXCL_START DumpManager::Config serviceInfoConfig; serviceInfoConfig.fullCmd = "--feature-info"; serviceInfoConfig.abbrCmd = "-f"; serviceInfoConfig.dumpName = "FEATURE_INFO"; serviceInfoConfig.dumpCaption = { "| Display all the service statistics" }; DumpManager::GetInstance().AddConfig("FEATURE_INFO", serviceInfoConfig); + // LCOV_EXCL_STOP } void ObjectServiceImpl::RegisterHandler() { + // LCOV_EXCL_START Handler handler = [this](int fd, std::map> ¶ms) { DumpObjectServiceInfo(fd, params); }; DumpManager::GetInstance().AddHandler("FEATURE_INFO", uintptr_t(this), handler); + // LCOV_EXCL_STOP } -// LCOV_EXCL_STOP void ObjectServiceImpl::DumpObjectServiceInfo(int fd, std::map> ¶ms) { diff --git a/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp index 43c578288..19775458e 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp +++ b/services/distributeddataservice/service/test/fuzztest/objectserviceimp2_fuzzer/objectserviceimp2_fuzzer.cpp @@ -35,9 +35,6 @@ void RegisterDataObserverFuzzTest(FuzzedDataProvider &provider) void OnAppUninstallFuzzTest(FuzzedDataProvider &provider) { std::shared_ptr objectServiceImpl = std::make_shared(); - if (objectServiceImpl->factory_.staticActs_ == nullptr) { - return; - } std::string bundleName = provider.ConsumeRandomLengthString(100); int32_t user = provider.ConsumeIntegral(); int32_t index = provider.ConsumeIntegral(); -- Gitee From 572102a612325b6cd470e0e289742f137af0f1bc Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Wed, 27 Aug 2025 15:17:04 +0800 Subject: [PATCH 65/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/cloud_service_impl.cpp | 4 +-- .../service/cloud/sync_manager.cpp | 25 +++++++++++++------ .../service/cloud/sync_manager.h | 6 ++--- .../service/test/cloud_service_impl_test.cpp | 10 ++++---- 4 files changed, 26 insertions(+), 19 deletions(-) diff --git a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp index 4542e32be..a1f141257 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_impl.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_impl.cpp @@ -808,7 +808,7 @@ int32_t CloudServiceImpl::OnReady(const std::string &device) Execute(GenTask(0, user, CloudSyncScene::NETWORK_RECOVERY, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB })); } - syncManager_.GetNetworkRecoveryManager().OnNetworkConnected(); + syncManager_.OnNetworkConnected(); return SUCCESS; } @@ -825,7 +825,7 @@ int32_t CloudServiceImpl::Offline(const std::string &device) } auto it = users.begin(); syncManager_.StopCloudSync(*it); - syncManager_.GetNetworkRecoveryManager().OnNetworkDisconnected(); + syncManager_.OnNetworkDisconnected(); return SUCCESS; } diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 1354cb407..39f53e224 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -1087,6 +1087,16 @@ int32_t SyncManager::ConvertValidGeneralCode(int32_t code) return (code >= E_OK && code < E_BUSY) ? code : E_ERROR; } +void SyncManager::OnNetworkDisconnected() +{ + networkRecoveryManager_.OnNetworkDisconnected(); +} + +void SyncManager::OnNetworkConnected() +{ + networkRecoveryManager_.OnNetworkConnected(); +} + void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() { ZLOGI("network disconnected."); @@ -1097,7 +1107,6 @@ void SyncManager::NetworkRecoveryManager::OnNetworkDisconnected() void SyncManager::NetworkRecoveryManager::OnNetworkConnected() { - ZLOGI("network connected start."); std::unique_ptr event; { std::lock_guard lock(eventMutex_); @@ -1126,17 +1135,17 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() syncManager_.DoCloudSync(SyncInfo(user, bundleName, "", {}, MODE_ONLINE)); } } - ZLOGI("network connected end, network disconnect duration :%{public}ld hours", hours); + ZLOGI("network connected success, network disconnect duration :%{public}ld hours", hours); } void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, const std::string &bundleName) { std::lock_guard lock(eventMutex_); if (currentEvent_) { - ZLOGI("record sync user:%{public}d, bundleName:%{public}s", user, bundleName.c_str()); auto &syncApps = currentEvent_->syncApps[user]; if (std::find(syncApps.begin(), syncApps.end(), bundleName) == syncApps.end()) { syncApps.push_back(bundleName); + ZLOGI("record sync user:%{public}d, bundleName:%{public}s", user, bundleName.c_str()); } } } @@ -1154,19 +1163,19 @@ std::vector SyncManager::NetworkRecoveryManager::GetAppList(const i appList.reserve(totalCount); std::unordered_set uniqueSet; uniqueSet.reserve(totalCount); - auto addApp = [&](const std::string &bundleName) { - if (uniqueSet.insert(bundleName).second) { - appList.push_back(bundleName); + auto addApp = [&](std::string bundleName) { + if (uniqueSet.insert(std::move(bundleName)).second) { + appList.push_back(std::move(bundleName)); } }; auto stores = CheckerManager::GetInstance().GetDynamicStores(); auto staticStores = CheckerManager::GetInstance().GetStaticStores(); stores.insert(stores.end(), staticStores.begin(), staticStores.end()); for (const auto &store : stores) { - addApp(store.bundleName); + addApp(std::move(store.bundleName)); } for (const auto &[_, app] : cloud.apps) { - addApp(app.bundleName); + addApp(std::move(app.bundleName)); } return appList; } diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index 89e36115b..ad5efa767 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -123,11 +123,9 @@ public: std::unique_ptr currentEvent_; SyncManager &syncManager_; }; - NetworkRecoveryManager &GetNetworkRecoveryManager() - { - return networkRecoveryManager_; - } + void OnNetworkDisconnected(); + void OnNetworkConnected(); private: using Event = DistributedData::Event; using Task = ExecutorPool::Task; diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp index e66f7ad97..bc45b8553 100644 --- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp @@ -1003,7 +1003,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest001, TestSize.Level0) cloudInfo.apps = apps; cloudInfo.user = MOCK_USER; MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); - auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_NE(recoveryManager.currentEvent_, nullptr); recoveryManager.RecordSyncApps(MOCK_USER, bundleName); @@ -1035,7 +1035,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest002, TestSize.Level0) users = { MOCK_USER }; return true; })); - auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_NE(recoveryManager.currentEvent_, nullptr); recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); @@ -1058,7 +1058,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest003, TestSize.Level0) users = { MOCK_USER }; return true; })); - auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; recoveryManager.RecordSyncApps(MOCK_USER, ""); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); @@ -1074,7 +1074,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest003, TestSize.Level0) HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); - auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; recoveryManager.OnNetworkDisconnected(); ASSERT_NE(recoveryManager.currentEvent_, nullptr); auto returnWithUserList = @@ -1127,7 +1127,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest005, TestSize.Level0) CloudInfo cloudInfo; cloudInfo.user = MOCK_USER; MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true); - auto &recoveryManager = cloudServiceImpl_->syncManager_.GetNetworkRecoveryManager(); + auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_NE(recoveryManager.currentEvent_, nullptr); recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); -- Gitee From 676971d7f5d32cb78cf2743a6b043f6ff85d8aa2 Mon Sep 17 00:00:00 2001 From: yangliu Date: Wed, 27 Aug 2025 17:46:46 +0800 Subject: [PATCH 66/76] update Signed-off-by: yangliu --- .../distributeddataservice/app/src/security/sensitive.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index 0b097a05a..bd5924bb2 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -113,12 +113,12 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) ZLOGE("init query params failed! udid:[%{public}s]", Anonymous::Change(udid).c_str()); return DATA_SEC_LEVEL1; } - auto ret = DATASL_OnStart(); - if (ret != DEVSL_SUCCESS) { + auto result = DATASL_OnStart(); + if (result != DEVSL_SUCCESS) { ZLOGI("datasl on start failed, ret:%{public}d", ret); return DATA_SEC_LEVEL1; } - uint32_t level = DATA_SEC_LEVEL1; + level = DATA_SEC_LEVEL1; int32_t result = DATASL_GetHighestSecLevel(&query, &level); DATASL_OnStop(); if (result != DEVSL_SUCCESS) { -- Gitee From 22f5fa48b6f02a11604f7b8c941756701843b2ca Mon Sep 17 00:00:00 2001 From: yangliu Date: Wed, 27 Aug 2025 17:48:42 +0800 Subject: [PATCH 67/76] update Signed-off-by: yangliu --- services/distributeddataservice/app/src/security/sensitive.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index bd5924bb2..0724e2953 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -119,7 +119,7 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) return DATA_SEC_LEVEL1; } level = DATA_SEC_LEVEL1; - int32_t result = DATASL_GetHighestSecLevel(&query, &level); + result = DATASL_GetHighestSecLevel(&query, &level); DATASL_OnStop(); if (result != DEVSL_SUCCESS) { ZLOGE("get highest level failed(%{public}s)! level: %{public}d, error: %d", -- Gitee From b89de0a9f37537815ed3bbc3a83fb6ebc6a56ae6 Mon Sep 17 00:00:00 2001 From: yangliu Date: Wed, 27 Aug 2025 18:10:00 +0800 Subject: [PATCH 68/76] update Signed-off-by: yangliu --- services/distributeddataservice/app/src/security/sensitive.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index 0724e2953..6687fc410 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -115,7 +115,7 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) } auto result = DATASL_OnStart(); if (result != DEVSL_SUCCESS) { - ZLOGI("datasl on start failed, ret:%{public}d", ret); + ZLOGI("datasl on start failed, ret:%{public}d", result); return DATA_SEC_LEVEL1; } level = DATA_SEC_LEVEL1; -- Gitee From ff82b1cce37fbd91625257be8065ed507fd2ed75 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Thu, 28 Aug 2025 10:40:53 +0800 Subject: [PATCH 69/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 13 ++++++++----- .../service/cloud/sync_manager.h | 2 +- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index 39f53e224..ee8fb3b06 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -48,7 +48,7 @@ using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter; using Defer = EventCenter::Defer; std::atomic SyncManager::genId_ = 0; constexpr int32_t SYSTEM_USER_ID = 0; -constexpr int32_t TIMEOUT_TIME = 20; // hours +constexpr int32_t NETWORK_DISCONNECT_TIMEOUT_HOURS = 20; static constexpr const char *FT_GET_STORE = "GET_STORE"; static constexpr const char *FT_CALLBACK = "CALLBACK"; SyncManager::SyncInfo::SyncInfo( @@ -515,6 +515,9 @@ bool SyncManager::HandleRetryFinished(const SyncInfo &info, int32_t user, int32_ if (code == E_OK || code == E_SYNC_TASK_MERGED) { return true; } + if (code == E_NETWORK_ERROR) { + networkRecoveryManager_.RecordSyncApps(user, info.bundleName_); + } info.SetError(code); RadarReporter::Report({ info.bundleName_.c_str(), CLOUD_SYNC, FINISH_SYNC, info.syncId_, info.triggerMode_, dbCode }, @@ -1110,7 +1113,7 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() std::unique_ptr event; { std::lock_guard lock(eventMutex_); - if (!currentEvent_) { + if (currentEvent_ == nullptr) { ZLOGE("network connected, but currentEvent_ is not initialized."); return; } @@ -1119,7 +1122,7 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() auto now = std::chrono::system_clock::now(); auto duration = now - event->disconnectTime; auto hours = std::chrono::duration_cast(duration).count(); - bool timeout = (hours > TIMEOUT_TIME); + bool timeout = (hours > NETWORK_DISCONNECT_TIMEOUT_HOURS); std::vector users; if (!Account::GetInstance()->QueryForegroundUsers(users) || users.empty()) { ZLOGE("no foreground user, skip sync."); @@ -1141,7 +1144,7 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() void SyncManager::NetworkRecoveryManager::RecordSyncApps(const int32_t user, const std::string &bundleName) { std::lock_guard lock(eventMutex_); - if (currentEvent_) { + if (currentEvent_ != nullptr) { auto &syncApps = currentEvent_->syncApps[user]; if (std::find(syncApps.begin(), syncApps.end(), bundleName) == syncApps.end()) { syncApps.push_back(bundleName); @@ -1164,7 +1167,7 @@ std::vector SyncManager::NetworkRecoveryManager::GetAppList(const i std::unordered_set uniqueSet; uniqueSet.reserve(totalCount); auto addApp = [&](std::string bundleName) { - if (uniqueSet.insert(std::move(bundleName)).second) { + if (uniqueSet.insert(bundleName).second) { appList.push_back(std::move(bundleName)); } }; diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index ad5efa767..443e75022 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -170,7 +170,7 @@ private: const std::string &message = ""); static void ReportSyncEvent(const DistributedData::SyncEvent &evt, DistributedDataDfx::BizState bizState, int32_t code); - static bool HandleRetryFinished(const SyncInfo &info, int32_t user, int32_t code, int32_t dbCode, + bool HandleRetryFinished(const SyncInfo &info, int32_t user, int32_t code, int32_t dbCode, const std::string &prepareTraceId); Task GetSyncTask(int32_t times, bool retry, RefCount ref, SyncInfo &&syncInfo); void UpdateSchema(const SyncInfo &syncInfo); -- Gitee From f993fecb726bf2090ce3cdbdb2a0d557dba4efb8 Mon Sep 17 00:00:00 2001 From: yangliu Date: Fri, 29 Aug 2025 10:30:45 +0800 Subject: [PATCH 70/76] update Signed-off-by: yangliu --- .../distributeddataservice/app/src/security/sensitive.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/app/src/security/sensitive.cpp b/services/distributeddataservice/app/src/security/sensitive.cpp index 6687fc410..dcc023e3c 100644 --- a/services/distributeddataservice/app/src/security/sensitive.cpp +++ b/services/distributeddataservice/app/src/security/sensitive.cpp @@ -115,10 +115,10 @@ uint32_t Sensitive::GetSensitiveLevel(const std::string &udid) } auto result = DATASL_OnStart(); if (result != DEVSL_SUCCESS) { - ZLOGI("datasl on start failed, ret:%{public}d", result); + ZLOGE("datasl on start failed, ret:%{public}d", result); return DATA_SEC_LEVEL1; } - level = DATA_SEC_LEVEL1; + uint32_t level = DATA_SEC_LEVEL1; result = DATASL_GetHighestSecLevel(&query, &level); DATASL_OnStop(); if (result != DEVSL_SUCCESS) { -- Gitee From d9f6961bb862a098d04759d649d7f620e1d61593 Mon Sep 17 00:00:00 2001 From: wan-xiaoqing321 Date: Fri, 22 Aug 2025 10:12:38 +0800 Subject: [PATCH 71/76] =?UTF-8?q?=E6=96=B0=E5=A2=9Etokenid=E5=88=A4?= =?UTF-8?q?=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wan-xiaoqing321 --- .../test/mock/preprocess_utils_mock.cpp | 4 +-- .../service/test/mock/preprocess_utils_mock.h | 4 +-- .../test/udmf_preprocess_utils_mock_test.cpp | 24 +++++++------- .../udmf/preprocess/preprocess_utils.cpp | 32 +++++++++++-------- .../udmf/preprocess/preprocess_utils.h | 4 +-- 5 files changed, 36 insertions(+), 32 deletions(-) diff --git a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp index c1d117dda..37238e41c 100644 --- a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp +++ b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.cpp @@ -82,13 +82,13 @@ int32_t PreProcessUtils::GetHapUidByToken(uint32_t tokenId, int &userId) return E_OK; } -bool PreProcessUtils::GetHapBundleNameByToken(int tokenId, std::string &bundleName) +bool PreProcessUtils::GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName) { bundleName = "processName"; return true; } -bool PreProcessUtils::GetNativeProcessNameByToken(int tokenId, std::string &processName) +bool PreProcessUtils::GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName) { processName = "processName"; return true; diff --git a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h index 92af6e73e..d71695fdb 100644 --- a/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h +++ b/services/distributeddataservice/service/test/mock/preprocess_utils_mock.h @@ -26,8 +26,8 @@ public: static std::string GenerateId(); static time_t GetTimestamp(); static int32_t GetHapUidByToken(uint32_t tokenId, int &userId); - static bool GetHapBundleNameByToken(int tokenId, std::string &bundleName); - static bool GetNativeProcessNameByToken(int tokenId, std::string &processName); + static bool GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName); + static bool GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName); static std::string GetLocalDeviceId(); static void SetRemoteData(UnifiedData &data); static int32_t SetRemoteUri(uint32_t tokenId, UnifiedData &data); diff --git a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp index 437bca9d4..0ca8e3b2d 100644 --- a/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp +++ b/services/distributeddataservice/service/test/udmf_preprocess_utils_mock_test.cpp @@ -55,7 +55,7 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetHapUidByToken001, TestSize.Level1) uint32_t tokenId = 0; int userId = 0; PreProcessUtils preProcessUtils; - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_SUCCESS)); int32_t ret = preProcessUtils.GetHapUidByToken(tokenId, userId); EXPECT_EQ(ret, E_OK); } @@ -71,8 +71,8 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetInstIndex001, TestSize.Level1) uint32_t tokenId = 0; int32_t instIndex = 0; PreProcessUtils preProcessUtils; - EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_HAP)); - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillRepeatedly(Return(TOKEN_HAP)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_SUCCESS)); bool ret = preProcessUtils.GetInstIndex(tokenId, instIndex); EXPECT_EQ(ret, true); } @@ -86,8 +86,8 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetInstIndex001, TestSize.Level1) HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId001, TestSize.Level1) { uint32_t tokenId = 0; - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); - EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_SHELL)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillRepeatedly(Return(TOKEN_SHELL)); std::string bundleName = ""; std::string specificBundleName = ""; PreProcessUtils preProcessUtils; @@ -104,9 +104,9 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId001, TestSi HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId002, TestSize.Level1) { uint32_t tokenId = 999; - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); - EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_NATIVE)); - EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillRepeatedly(Return(TOKEN_NATIVE)); + EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillRepeatedly(Return(RET_SUCCESS)); std::string bundleName = ""; std::string specificBundleName = ""; PreProcessUtils preProcessUtils; @@ -123,7 +123,7 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId002, TestSi HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId003, TestSize.Level1) { uint32_t tokenId = 9999; - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_SUCCESS)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_SUCCESS)); std::string bundleName = ""; std::string specificBundleName = ""; PreProcessUtils preProcessUtils; @@ -140,9 +140,9 @@ HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId003, TestSi HWTEST_F(UdmfPreProcessUtilsMockTest, GetAlterableBundleNameByTokenId004, TestSize.Level1) { uint32_t tokenId = 999; - EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); - EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillOnce(Return(TOKEN_NATIVE)); - EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillOnce(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetHapTokenInfo(_, _)).WillRepeatedly(Return(RET_FAILED)); + EXPECT_CALL(*accessTokenKitMock, GetTokenTypeFlag(_)).WillRepeatedly(Return(TOKEN_NATIVE)); + EXPECT_CALL(*accessTokenKitMock, GetNativeTokenInfo(_, _)).WillRepeatedly(Return(RET_FAILED)); std::string bundleName = ""; std::string specificBundleName = ""; PreProcessUtils preProcessUtils; diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp index 5a8f2e146..9e7c45d15 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp @@ -111,6 +111,10 @@ time_t PreProcessUtils::GetTimestamp() int32_t PreProcessUtils::GetHapUidByToken(uint32_t tokenId, int &userId) { + if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) { + ZLOGE("TokenType is not TOKEN_HAP"); + return E_ERROR; + } Security::AccessToken::HapTokenInfo tokenInfo; auto result = Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo); if (result != Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { @@ -121,14 +125,8 @@ int32_t PreProcessUtils::GetHapUidByToken(uint32_t tokenId, int &userId) return E_OK; } -bool PreProcessUtils::GetHapBundleNameByToken(int tokenId, std::string &bundleName) +bool PreProcessUtils::GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName) { - Security::AccessToken::HapTokenInfo hapInfo; - if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) - == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { - bundleName = hapInfo.bundleName; - return true; - } if (UTILS::IsTokenNative()) { ZLOGD("TypeATokenTypeEnum is TOKEN_HAP"); std::string processName; @@ -137,11 +135,17 @@ bool PreProcessUtils::GetHapBundleNameByToken(int tokenId, std::string &bundleNa return true; } } + Security::AccessToken::HapTokenInfo hapInfo; + if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) + == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { + bundleName = hapInfo.bundleName; + return true; + } ZLOGE("Get bundle name faild"); return false; } -bool PreProcessUtils::GetNativeProcessNameByToken(int tokenId, std::string &processName) +bool PreProcessUtils::GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName) { Security::AccessToken::NativeTokenInfo nativeInfo; if (Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(tokenId, nativeInfo) @@ -503,12 +507,6 @@ std::string PreProcessUtils::GetSdkVersionByToken(uint32_t tokenId) bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::string &specificBundleName, std::string &bundleName) { - Security::AccessToken::HapTokenInfo hapInfo; - if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) - == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { - bundleName = hapInfo.bundleName; - return GetSpecificBundleName(hapInfo.bundleName, hapInfo.instIndex, specificBundleName); - } if (UTILS::IsTokenNative()) { ZLOGI("TypeATokenTypeEnum is TOKEN_NATIVE"); std::string processName; @@ -518,6 +516,12 @@ bool PreProcessUtils::GetSpecificBundleNameByTokenId(uint32_t tokenId, std::stri return true; } } + Security::AccessToken::HapTokenInfo hapInfo; + if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, hapInfo) + == Security::AccessToken::AccessTokenKitRet::RET_SUCCESS) { + bundleName = hapInfo.bundleName; + return GetSpecificBundleName(hapInfo.bundleName, hapInfo.instIndex, specificBundleName); + } ZLOGE("Get bundle name faild, tokenid:%{public}u", tokenId); return false; } diff --git a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h index e378592c8..1ebe94d0b 100644 --- a/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h +++ b/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h @@ -26,8 +26,8 @@ public: static std::string GenerateId(); static time_t GetTimestamp(); static int32_t GetHapUidByToken(uint32_t tokenId, int &userId); - static bool GetHapBundleNameByToken(int tokenId, std::string &bundleName); - static bool GetNativeProcessNameByToken(int tokenId, std::string &processName); + static bool GetHapBundleNameByToken(uint32_t tokenId, std::string &bundleName); + static bool GetNativeProcessNameByToken(uint32_t tokenId, std::string &processName); static std::string GetLocalDeviceId(); static void SetRemoteData(UnifiedData &data); static int32_t SetRemoteUri(uint32_t tokenId, UnifiedData &data); -- Gitee From d09639a536cbdfa35a1a5d30ea904019aa7d48b6 Mon Sep 17 00:00:00 2001 From: wangbin Date: Fri, 29 Aug 2025 14:33:33 +0800 Subject: [PATCH 72/76] fix Signed-off-by: wangbin --- .../service/test/rdb_cloud_test1.cpp | 423 ++++++++++++++++++ 1 file changed, 423 insertions(+) create mode 100644 services/distributeddataservice/service/test/rdb_cloud_test1.cpp diff --git a/services/distributeddataservice/service/test/rdb_cloud_test1.cpp b/services/distributeddataservice/service/test/rdb_cloud_test1.cpp new file mode 100644 index 000000000..2683faa96 --- /dev/null +++ b/services/distributeddataservice/service/test/rdb_cloud_test1.cpp @@ -0,0 +1,423 @@ +/* + * 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. + */ +#define LOG_TAG "RdbCloudTest" + +#include "rdb_cloud.h" + +#include "cloud_db_mock.h" +#include "cursor_mock.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "log_print.h" + +using namespace testing::ext; +using namespace testing; +using namespace OHOS::DistributedData; +using namespace OHOS::DistributedRdb; +using DBVBucket = DistributedDB::VBucket; +using DBStatus = DistributedDB::DBStatus; +using DBAsset = DistributedDB::Asset; +using DBAssets = DistributedDB::Assets; +using AssetOpType = DistributedDB::AssetOpType; +using AssetStatus = DistributedDB::AssetStatus; +DBAsset assetValue1 = { .version = 1, + .name = "texture_diffuse", + .assetId = "123", + .subpath = "textures/environment", + .uri = "http://asset.com/textures/123.jpg", + .modifyTime = "2025-04-05T12:30:00Z", + .createTime = "2025-04-05T10:15:00Z", + .size = "1024", + .hash = "sha256-abc123", + .flag = static_cast(AssetOpType::INSERT), + .status = static_cast(AssetStatus::NORMAL), + .timestamp = std::time(nullptr) }; + +DBAsset assetValue2 = { .version = 2, + .name = "texture_diffuse", + .assetId = "456", + .subpath = "textures/environment", + .uri = "http://asset.com/textures/456.jpg", + .modifyTime = "2025-06-19T12:30:00Z", + .createTime = "2025-04-05T10:15:00Z", + .size = "1024", + .hash = "sha256-abc456", + .flag = static_cast(AssetOpType::UPDATE), + .status = static_cast(AssetStatus::NORMAL), + .timestamp = std::time(nullptr) }; + +DBAssets assetsValue = { assetValue1, assetValue2 }; +std::vector g_DBVBuckets = { { { "#gid", { "0000000" } }, { "#flag", { true } }, + { "#value", { int64_t(100) } }, { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, + { "#_error", { "E_ERROR" } }, { "#_error", { "INVALID" } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } }, + { "#asset", assetValue1 }, { "#assets", assetsValue } } }; +DBVBucket g_DBVBucket = { { "#value", { int64_t(100) } } }; + +namespace OHOS::Test { +namespace DistributedRDBTest { +class RdbCloudTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(){}; + void TearDown(){}; + static inline std::shared_ptr mockCloudDB = nullptr; + static constexpr int32_t COUNT = 2; +}; + +void RdbCloudTest::SetUpTestCase() +{ + mockCloudDB = std::make_shared(); +} + +void RdbCloudTest::TearDownTestCase() +{ + mockCloudDB = nullptr; +} + +/** +* @tc.name: RdbCloudTest001 +* @tc.desc: RdbCloud BatchInsert BatchUpdate BatchDelete test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, RdbCloudTest001, TestSize.Level1) +{ + BindAssets bindAssets; + Bytes bytes; + RdbCloud rdbCloud(std::make_shared(), bindAssets); + std::string tableName = "testTable"; + + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + + std::vector dataUpdate = g_DBVBuckets; + std::vector extendUpdate = g_DBVBuckets; + result = rdbCloud.BatchUpdate(tableName, std::move(dataUpdate), extendUpdate); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + + std::vector extendDelete = g_DBVBuckets; + result = rdbCloud.BatchDelete(tableName, extendDelete); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: RdbCloudTest002 +* @tc.desc: RdbCloud Query PreSharing HeartBeat Close test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, RdbCloudTest002, TestSize.Level1) +{ + BindAssets bindAssets; + RdbCloud rdbCloud(std::make_shared(), bindAssets); + std::string tableName = "testTable"; + rdbCloud.Lock(); + std::string traceId = "id"; + rdbCloud.SetPrepareTraceId(traceId); + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + DBVBucket extends = { { "#gid", { "00000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } }; + result = rdbCloud.Query(tableName, extends, g_DBVBuckets); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + std::vector vBuckets = { { { "#gid", { "00000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } } }; + rdbCloud.PreSharing(tableName, vBuckets); + result = rdbCloud.HeartBeat(); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + rdbCloud.UnLock(); + rdbCloud.GetEmptyCursor(tableName); + result = rdbCloud.Close(); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: RdbCloudTest003 +* @tc.desc: RdbCloud Query error test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, RdbCloudTest003, TestSize.Level1) +{ + BindAssets bindAssets = nullptr; + RdbCloud rdbCloud(std::make_shared(), bindAssets); + std::string tableName = "testTable"; + DBVBucket extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } }, { "#_type", { int64_t(1) } } }; + std::vector data = { { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } } } }; + auto result = rdbCloud.Query(tableName, extends, data); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + + extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } }; + result = rdbCloud.Query(tableName, extends, data); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); + + extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, + { "#float", { double(100) } }, { "#_type", { int64_t(0) } } }; + result = rdbCloud.Query(tableName, extends, data); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: RdbCloudTest004 +* @tc.desc: RdbCloud UnLockCloudDB LockCloudDB InnerUnLock test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, RdbCloudTest004, TestSize.Level1) +{ + BindAssets bindAssets; + RdbCloud rdbCloud(std::make_shared(), bindAssets); + + auto err = rdbCloud.UnLockCloudDB(OHOS::DistributedRdb::RdbCloud::FLAG::SYSTEM_ABILITY); + EXPECT_EQ(err, GeneralError::E_NOT_SUPPORT); + + auto result = rdbCloud.LockCloudDB(OHOS::DistributedRdb::RdbCloud::FLAG::SYSTEM_ABILITY); + EXPECT_EQ(result.first, GeneralError::E_NOT_SUPPORT); + + rdbCloud.flag_ = 1; + err = rdbCloud.InnerUnLock(static_cast(0)); + EXPECT_EQ(err, GeneralError::E_OK); +} + +/** +* @tc.name: ConvertStatus +* @tc.desc: RdbCloud ConvertStatus function test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, ConvertStatus, TestSize.Level1) +{ + BindAssets bindAssets; + RdbCloud rdbCloud(std::make_shared(), bindAssets); + auto result = rdbCloud.ConvertStatus(GeneralError::E_OK); + EXPECT_EQ(result, DBStatus::OK); + result = rdbCloud.ConvertStatus(GeneralError::E_NETWORK_ERROR); + EXPECT_EQ(result, DBStatus::CLOUD_NETWORK_ERROR); + result = rdbCloud.ConvertStatus(GeneralError::E_LOCKED_BY_OTHERS); + EXPECT_EQ(result, DBStatus::CLOUD_LOCK_ERROR); + result = rdbCloud.ConvertStatus(GeneralError::E_RECODE_LIMIT_EXCEEDED); + EXPECT_EQ(result, DBStatus::CLOUD_FULL_RECORDS); + result = rdbCloud.ConvertStatus(GeneralError::E_NO_SPACE_FOR_ASSET); + EXPECT_EQ(result, DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT); + result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_EXIST_CONFLICT); + EXPECT_EQ(result, DBStatus::CLOUD_RECORD_EXIST_CONFLICT); + result = rdbCloud.ConvertStatus(GeneralError::E_VERSION_CONFLICT); + EXPECT_EQ(result, DBStatus::CLOUD_VERSION_CONFLICT); + result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_NOT_FOUND); + EXPECT_EQ(result, DBStatus::CLOUD_RECORD_NOT_FOUND); + result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_ALREADY_EXISTED); + EXPECT_EQ(result, DBStatus::CLOUD_RECORD_ALREADY_EXISTED); + result = rdbCloud.ConvertStatus(GeneralError::E_FILE_NOT_EXIST); + EXPECT_EQ(result, DBStatus::LOCAL_ASSET_NOT_FOUND); + result = rdbCloud.ConvertStatus(GeneralError::E_TIME_OUT); + EXPECT_EQ(result, DBStatus::TIME_OUT); + result = rdbCloud.ConvertStatus(GeneralError::E_CLOUD_DISABLED); + EXPECT_EQ(result, DBStatus::CLOUD_DISABLED); +} + +/** +* @tc.name: ConvertQuery +* @tc.desc: RdbCloud ConvertQuery function test. +* @tc.type: FUNC +* @tc.require: +* @tc.author: SQL +*/ +HWTEST_F(RdbCloudTest, ConvertQuery, TestSize.Level1) +{ + RdbCloud::DBQueryNodes nodes; + DistributedDB::QueryNode node = { DistributedDB::QueryNodeType::IN, "", { int64_t(1) } }; + nodes.push_back(node); + node = { DistributedDB::QueryNodeType::OR, "", { int64_t(1) } }; + nodes.push_back(node); + node = { DistributedDB::QueryNodeType::AND, "", { int64_t(1) } }; + nodes.push_back(node); + node = { DistributedDB::QueryNodeType::EQUAL_TO, "", { int64_t(1) } }; + nodes.push_back(node); + node = { DistributedDB::QueryNodeType::BEGIN_GROUP, "", { int64_t(1) } }; + nodes.push_back(node); + node = { DistributedDB::QueryNodeType::END_GROUP, "", { int64_t(1) } }; + nodes.push_back(node); + + auto result = RdbCloud::ConvertQuery(std::move(nodes)); + EXPECT_EQ(result.size(), 6); + + nodes.clear(); + node = { DistributedDB::QueryNodeType::ILLEGAL, "", { int64_t(1) } }; + nodes.push_back(node); + result = RdbCloud::ConvertQuery(std::move(nodes)); + EXPECT_EQ(result.size(), 0); +} + +/** +* @tc.name: SetPrepareTraceId001 +* @tc.desc: RdbCloud PostEvent test cloudDB_ is nullptr. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, SetPrepareTraceId001, TestSize.Level1) +{ + std::string traceId = "testId"; + EXPECT_CALL(*mockCloudDB, SetPrepareTraceId(_)).Times(0); + BindAssets bindAssets; + std::shared_ptr mockCloudDB = nullptr; + RdbCloud rdbCloud(mockCloudDB, bindAssets); + rdbCloud.SetPrepareTraceId(traceId); +} + +/** +* @tc.name: PostEvent001 +* @tc.desc: RdbCloud PostEvent test bindAssets is nullptr. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, PostEvent001, TestSize.Level1) +{ + BindAssets bindAssets; + RdbCloud rdbCloud(std::make_shared(), nullptr); + std::string traceId = "testId"; + rdbCloud.SetPrepareTraceId(traceId); + std::string tableName = "testTable"; + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: PostEvent002 +* @tc.desc: RdbCloud PostEvent test snapshots contains asset.uri. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, PostEvent002, TestSize.Level1) +{ + BindAssets snapshots = std::make_shared>>(); + std::shared_ptr snapshot; + snapshots->insert_or_assign(assetValue1.uri, snapshot); + RdbCloud rdbCloud(std::make_shared(), snapshots); + std::string tableName = "testTable"; + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: PostEvent003 +* @tc.desc: RdbCloud PostEvent test snapshots does not contains asset.uri. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, PostEvent003, TestSize.Level1) +{ + BindAssets snapshots = std::make_shared>>(); + std::shared_ptr snapshot; + std::string uri = "testuri"; + snapshots->insert_or_assign(uri, snapshot); + RdbCloud rdbCloud(std::make_shared(), snapshots); + std::string tableName = "testTable"; + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: PostEvent004 +* @tc.desc: RdbCloud PostEvent test the snapshot contained in the snapshots is nullpt. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, PostEvent004, TestSize.Level1) +{ + BindAssets snapshots = std::make_shared>>(); + std::shared_ptr snapshot = nullptr; + std::string uri = "testuri"; + snapshots->insert_or_assign(uri, snapshot); + RdbCloud rdbCloud(std::make_shared(), snapshots); + std::string tableName = "testTable"; + std::vector dataInsert = g_DBVBuckets; + std::vector extendInsert = g_DBVBuckets; + auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} + +/** +* @tc.name: Query001 +* @tc.desc: RdbCloud Query test the cursor is nullptr and code is not E_OK. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, Query001, TestSize.Level1) +{ + std::shared_ptr cursor = nullptr; + std::string tableName = "testTable"; + EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_NETWORK_ERROR, cursor))); + BindAssets snapshots; + RdbCloud rdbCloud(mockCloudDB, snapshots); + auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); + EXPECT_EQ(result, DBStatus::CLOUD_NETWORK_ERROR); +} + +/** +* @tc.name: Query002 +* @tc.desc: RdbCloud Query test code is QUERY_END. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, Query002, TestSize.Level1) +{ + std::shared_ptr mockCursor = std::make_shared(); + std::string tableName = "testTable"; + EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_OK, mockCursor))); + EXPECT_CALL(*mockCursor, GetCount()).WillOnce(Return(COUNT)); + EXPECT_CALL(*mockCursor, GetEntry(_)).WillOnce(Return(E_OK)).WillOnce(Return(E_ERROR)); + EXPECT_CALL(*mockCursor, MoveToNext()).WillRepeatedly(Return(E_OK)); + EXPECT_CALL(*mockCursor, IsEnd()).WillOnce(Return(true)); + + BindAssets snapshots; + RdbCloud rdbCloud(mockCloudDB, snapshots); + auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); + EXPECT_EQ(result, DBStatus::QUERY_END); +} + +/** +* @tc.name: Query003 +* @tc.desc: RdbCloud Query test code is CLOUD_ERROR. +* @tc.type: FUNC +*/ +HWTEST_F(RdbCloudTest, Query003, TestSize.Level1) +{ + std::shared_ptr mockCursor = std::make_shared(); + std::string tableName = "testTable"; + EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_OK, mockCursor))); + EXPECT_CALL(*mockCursor, GetCount()).WillOnce(Return(COUNT)); + EXPECT_CALL(*mockCursor, GetEntry(_)).WillOnce(Return(E_OK)).WillOnce(Return(E_ERROR)); + EXPECT_CALL(*mockCursor, MoveToNext()).WillRepeatedly(Return(E_OK)); + EXPECT_CALL(*mockCursor, IsEnd()).WillOnce(Return(false)); + + BindAssets snapshots; + RdbCloud rdbCloud(mockCloudDB, snapshots); + auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); + EXPECT_EQ(result, DBStatus::CLOUD_ERROR); +} +} // namespace DistributedRDBTest +} // namespace OHOS::Test \ No newline at end of file -- Gitee From be64089c76435806e6f2d378065d70d35cf2c62a Mon Sep 17 00:00:00 2001 From: wangbin Date: Fri, 29 Aug 2025 14:36:31 +0800 Subject: [PATCH 73/76] =?UTF-8?q?=E4=B8=80=E8=87=B4=E6=80=A7=E4=BF=AE?= =?UTF-8?q?=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangbin --- .../service/kvdb/kvdb_general_store.h | 4 +- .../service/kvdb/kvdb_service_impl.cpp | 4 +- .../service/test/kvdb_service_impl_test.cpp | 25 ++ .../service/test/rdb_cloud_test1.cpp | 423 ------------------ 4 files changed, 29 insertions(+), 427 deletions(-) delete mode 100644 services/distributeddataservice/service/test/rdb_cloud_test1.cpp diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.h b/services/distributeddataservice/service/kvdb/kvdb_general_store.h index 80e030f05..b5849b018 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.h +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.h @@ -97,8 +97,8 @@ private: DBProcessCB GetDBProcessCB(DetailAsync async); DBStatus CloudSync(const Devices &devices, DistributedDB::SyncMode cloudSyncMode, DetailAsync async, int64_t wait, const std::string &prepareTraceId); - void GetIdentifierParams( - std::vector &devices, const std::vector &uuids, int32_t authType); + void GetIdentifierParams(std::vector &devices, + const std::vector &uuids, int32_t authType); void Report(const std::string &faultType, int32_t errCode, const std::string &appendix); class ObserverProxy : public DistributedDB::KvStoreObserver { public: diff --git a/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp b/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp index c497a1288..5bce7eda4 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp +++ b/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp @@ -104,9 +104,9 @@ void KVDBServiceImpl::Init() StoreMetaMapping meta(storeInfo); meta.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid; if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + ZLOGE("meta empty, bundleName:%{public}s, storeId:%{public}s, user = %{public}s", meta.bundleName.c_str(), + meta.GetStoreAlias().c_str(), meta.user.c_str()); if (meta.user == "0") { - ZLOGE("meta empty, bundleName:%{public}s, storeId:%{public}s, user = %{public}s", - meta.bundleName.c_str(), meta.GetStoreAlias().c_str(), meta.user.c_str()); return; } meta.user = "0"; diff --git a/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp b/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp index 039577976..1d0d7d625 100644 --- a/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp @@ -325,6 +325,31 @@ HWTEST_F(KvdbServiceImplTest, OnInitialize001, TestSize.Level0) EXPECT_EQ(result, 1); // CODE_SYNC } +/** +* @tc.name: OnInitialize002 +* @tc.desc: OnInitialize function test. +* @tc.type: FUNC +* @tc.author: my +*/ +HWTEST_F(KvdbServiceImplTest, OnInitialize002, TestSize.Level0) +{ + auto result = kvdbServiceImpl_->OnInitialize(); + EXPECT_EQ(result, Status::SUCCESS); + DistributedData::StoreInfo storeInfo; + storeInfo.bundleName = "bundleName"; + storeInfo.storeName = "storeName"; + storeInfo.user = 100; + + EXPECT_CALL(*metaDataManagerMock, LoadMeta(testing::_, testing::_, testing::_)) + .WillOnce(testing::Return(false)) + .WillRepeatedly(testing::Return(true)); + + auto event = std::make_unique(CloudEvent::CLOUD_SYNC, storeInfo); + EXPECT_NE(event, nullptr); + result = EventCenter::GetInstance().PostEvent(move(event)); + EXPECT_EQ(result, 1); // CODE_SYNC +} + /** * @tc.name: GetStoreIdsTest001 * @tc.desc: GetStoreIds diff --git a/services/distributeddataservice/service/test/rdb_cloud_test1.cpp b/services/distributeddataservice/service/test/rdb_cloud_test1.cpp deleted file mode 100644 index 2683faa96..000000000 --- a/services/distributeddataservice/service/test/rdb_cloud_test1.cpp +++ /dev/null @@ -1,423 +0,0 @@ -/* - * 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. - */ -#define LOG_TAG "RdbCloudTest" - -#include "rdb_cloud.h" - -#include "cloud_db_mock.h" -#include "cursor_mock.h" -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "log_print.h" - -using namespace testing::ext; -using namespace testing; -using namespace OHOS::DistributedData; -using namespace OHOS::DistributedRdb; -using DBVBucket = DistributedDB::VBucket; -using DBStatus = DistributedDB::DBStatus; -using DBAsset = DistributedDB::Asset; -using DBAssets = DistributedDB::Assets; -using AssetOpType = DistributedDB::AssetOpType; -using AssetStatus = DistributedDB::AssetStatus; -DBAsset assetValue1 = { .version = 1, - .name = "texture_diffuse", - .assetId = "123", - .subpath = "textures/environment", - .uri = "http://asset.com/textures/123.jpg", - .modifyTime = "2025-04-05T12:30:00Z", - .createTime = "2025-04-05T10:15:00Z", - .size = "1024", - .hash = "sha256-abc123", - .flag = static_cast(AssetOpType::INSERT), - .status = static_cast(AssetStatus::NORMAL), - .timestamp = std::time(nullptr) }; - -DBAsset assetValue2 = { .version = 2, - .name = "texture_diffuse", - .assetId = "456", - .subpath = "textures/environment", - .uri = "http://asset.com/textures/456.jpg", - .modifyTime = "2025-06-19T12:30:00Z", - .createTime = "2025-04-05T10:15:00Z", - .size = "1024", - .hash = "sha256-abc456", - .flag = static_cast(AssetOpType::UPDATE), - .status = static_cast(AssetStatus::NORMAL), - .timestamp = std::time(nullptr) }; - -DBAssets assetsValue = { assetValue1, assetValue2 }; -std::vector g_DBVBuckets = { { { "#gid", { "0000000" } }, { "#flag", { true } }, - { "#value", { int64_t(100) } }, { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, - { "#_error", { "E_ERROR" } }, { "#_error", { "INVALID" } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } }, - { "#asset", assetValue1 }, { "#assets", assetsValue } } }; -DBVBucket g_DBVBucket = { { "#value", { int64_t(100) } } }; - -namespace OHOS::Test { -namespace DistributedRDBTest { -class RdbCloudTest : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp(){}; - void TearDown(){}; - static inline std::shared_ptr mockCloudDB = nullptr; - static constexpr int32_t COUNT = 2; -}; - -void RdbCloudTest::SetUpTestCase() -{ - mockCloudDB = std::make_shared(); -} - -void RdbCloudTest::TearDownTestCase() -{ - mockCloudDB = nullptr; -} - -/** -* @tc.name: RdbCloudTest001 -* @tc.desc: RdbCloud BatchInsert BatchUpdate BatchDelete test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, RdbCloudTest001, TestSize.Level1) -{ - BindAssets bindAssets; - Bytes bytes; - RdbCloud rdbCloud(std::make_shared(), bindAssets); - std::string tableName = "testTable"; - - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - - std::vector dataUpdate = g_DBVBuckets; - std::vector extendUpdate = g_DBVBuckets; - result = rdbCloud.BatchUpdate(tableName, std::move(dataUpdate), extendUpdate); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - - std::vector extendDelete = g_DBVBuckets; - result = rdbCloud.BatchDelete(tableName, extendDelete); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: RdbCloudTest002 -* @tc.desc: RdbCloud Query PreSharing HeartBeat Close test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, RdbCloudTest002, TestSize.Level1) -{ - BindAssets bindAssets; - RdbCloud rdbCloud(std::make_shared(), bindAssets); - std::string tableName = "testTable"; - rdbCloud.Lock(); - std::string traceId = "id"; - rdbCloud.SetPrepareTraceId(traceId); - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - DBVBucket extends = { { "#gid", { "00000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } }; - result = rdbCloud.Query(tableName, extends, g_DBVBuckets); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - std::vector vBuckets = { { { "#gid", { "00000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } }, { "#_type", { int64_t(1) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } } }; - rdbCloud.PreSharing(tableName, vBuckets); - result = rdbCloud.HeartBeat(); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - rdbCloud.UnLock(); - rdbCloud.GetEmptyCursor(tableName); - result = rdbCloud.Close(); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: RdbCloudTest003 -* @tc.desc: RdbCloud Query error test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, RdbCloudTest003, TestSize.Level1) -{ - BindAssets bindAssets = nullptr; - RdbCloud rdbCloud(std::make_shared(), bindAssets); - std::string tableName = "testTable"; - DBVBucket extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } }, { "#_type", { int64_t(1) } } }; - std::vector data = { { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } } } }; - auto result = rdbCloud.Query(tableName, extends, data); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - - extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } }, { "#_query", { Bytes({ 1, 2, 3, 4 }) } } }; - result = rdbCloud.Query(tableName, extends, data); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); - - extends = { { "#gid", { "0000000" } }, { "#flag", { true } }, { "#value", { int64_t(100) } }, - { "#float", { double(100) } }, { "#_type", { int64_t(0) } } }; - result = rdbCloud.Query(tableName, extends, data); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: RdbCloudTest004 -* @tc.desc: RdbCloud UnLockCloudDB LockCloudDB InnerUnLock test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, RdbCloudTest004, TestSize.Level1) -{ - BindAssets bindAssets; - RdbCloud rdbCloud(std::make_shared(), bindAssets); - - auto err = rdbCloud.UnLockCloudDB(OHOS::DistributedRdb::RdbCloud::FLAG::SYSTEM_ABILITY); - EXPECT_EQ(err, GeneralError::E_NOT_SUPPORT); - - auto result = rdbCloud.LockCloudDB(OHOS::DistributedRdb::RdbCloud::FLAG::SYSTEM_ABILITY); - EXPECT_EQ(result.first, GeneralError::E_NOT_SUPPORT); - - rdbCloud.flag_ = 1; - err = rdbCloud.InnerUnLock(static_cast(0)); - EXPECT_EQ(err, GeneralError::E_OK); -} - -/** -* @tc.name: ConvertStatus -* @tc.desc: RdbCloud ConvertStatus function test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, ConvertStatus, TestSize.Level1) -{ - BindAssets bindAssets; - RdbCloud rdbCloud(std::make_shared(), bindAssets); - auto result = rdbCloud.ConvertStatus(GeneralError::E_OK); - EXPECT_EQ(result, DBStatus::OK); - result = rdbCloud.ConvertStatus(GeneralError::E_NETWORK_ERROR); - EXPECT_EQ(result, DBStatus::CLOUD_NETWORK_ERROR); - result = rdbCloud.ConvertStatus(GeneralError::E_LOCKED_BY_OTHERS); - EXPECT_EQ(result, DBStatus::CLOUD_LOCK_ERROR); - result = rdbCloud.ConvertStatus(GeneralError::E_RECODE_LIMIT_EXCEEDED); - EXPECT_EQ(result, DBStatus::CLOUD_FULL_RECORDS); - result = rdbCloud.ConvertStatus(GeneralError::E_NO_SPACE_FOR_ASSET); - EXPECT_EQ(result, DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT); - result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_EXIST_CONFLICT); - EXPECT_EQ(result, DBStatus::CLOUD_RECORD_EXIST_CONFLICT); - result = rdbCloud.ConvertStatus(GeneralError::E_VERSION_CONFLICT); - EXPECT_EQ(result, DBStatus::CLOUD_VERSION_CONFLICT); - result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_NOT_FOUND); - EXPECT_EQ(result, DBStatus::CLOUD_RECORD_NOT_FOUND); - result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_ALREADY_EXISTED); - EXPECT_EQ(result, DBStatus::CLOUD_RECORD_ALREADY_EXISTED); - result = rdbCloud.ConvertStatus(GeneralError::E_FILE_NOT_EXIST); - EXPECT_EQ(result, DBStatus::LOCAL_ASSET_NOT_FOUND); - result = rdbCloud.ConvertStatus(GeneralError::E_TIME_OUT); - EXPECT_EQ(result, DBStatus::TIME_OUT); - result = rdbCloud.ConvertStatus(GeneralError::E_CLOUD_DISABLED); - EXPECT_EQ(result, DBStatus::CLOUD_DISABLED); -} - -/** -* @tc.name: ConvertQuery -* @tc.desc: RdbCloud ConvertQuery function test. -* @tc.type: FUNC -* @tc.require: -* @tc.author: SQL -*/ -HWTEST_F(RdbCloudTest, ConvertQuery, TestSize.Level1) -{ - RdbCloud::DBQueryNodes nodes; - DistributedDB::QueryNode node = { DistributedDB::QueryNodeType::IN, "", { int64_t(1) } }; - nodes.push_back(node); - node = { DistributedDB::QueryNodeType::OR, "", { int64_t(1) } }; - nodes.push_back(node); - node = { DistributedDB::QueryNodeType::AND, "", { int64_t(1) } }; - nodes.push_back(node); - node = { DistributedDB::QueryNodeType::EQUAL_TO, "", { int64_t(1) } }; - nodes.push_back(node); - node = { DistributedDB::QueryNodeType::BEGIN_GROUP, "", { int64_t(1) } }; - nodes.push_back(node); - node = { DistributedDB::QueryNodeType::END_GROUP, "", { int64_t(1) } }; - nodes.push_back(node); - - auto result = RdbCloud::ConvertQuery(std::move(nodes)); - EXPECT_EQ(result.size(), 6); - - nodes.clear(); - node = { DistributedDB::QueryNodeType::ILLEGAL, "", { int64_t(1) } }; - nodes.push_back(node); - result = RdbCloud::ConvertQuery(std::move(nodes)); - EXPECT_EQ(result.size(), 0); -} - -/** -* @tc.name: SetPrepareTraceId001 -* @tc.desc: RdbCloud PostEvent test cloudDB_ is nullptr. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, SetPrepareTraceId001, TestSize.Level1) -{ - std::string traceId = "testId"; - EXPECT_CALL(*mockCloudDB, SetPrepareTraceId(_)).Times(0); - BindAssets bindAssets; - std::shared_ptr mockCloudDB = nullptr; - RdbCloud rdbCloud(mockCloudDB, bindAssets); - rdbCloud.SetPrepareTraceId(traceId); -} - -/** -* @tc.name: PostEvent001 -* @tc.desc: RdbCloud PostEvent test bindAssets is nullptr. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, PostEvent001, TestSize.Level1) -{ - BindAssets bindAssets; - RdbCloud rdbCloud(std::make_shared(), nullptr); - std::string traceId = "testId"; - rdbCloud.SetPrepareTraceId(traceId); - std::string tableName = "testTable"; - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: PostEvent002 -* @tc.desc: RdbCloud PostEvent test snapshots contains asset.uri. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, PostEvent002, TestSize.Level1) -{ - BindAssets snapshots = std::make_shared>>(); - std::shared_ptr snapshot; - snapshots->insert_or_assign(assetValue1.uri, snapshot); - RdbCloud rdbCloud(std::make_shared(), snapshots); - std::string tableName = "testTable"; - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: PostEvent003 -* @tc.desc: RdbCloud PostEvent test snapshots does not contains asset.uri. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, PostEvent003, TestSize.Level1) -{ - BindAssets snapshots = std::make_shared>>(); - std::shared_ptr snapshot; - std::string uri = "testuri"; - snapshots->insert_or_assign(uri, snapshot); - RdbCloud rdbCloud(std::make_shared(), snapshots); - std::string tableName = "testTable"; - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: PostEvent004 -* @tc.desc: RdbCloud PostEvent test the snapshot contained in the snapshots is nullpt. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, PostEvent004, TestSize.Level1) -{ - BindAssets snapshots = std::make_shared>>(); - std::shared_ptr snapshot = nullptr; - std::string uri = "testuri"; - snapshots->insert_or_assign(uri, snapshot); - RdbCloud rdbCloud(std::make_shared(), snapshots); - std::string tableName = "testTable"; - std::vector dataInsert = g_DBVBuckets; - std::vector extendInsert = g_DBVBuckets; - auto result = rdbCloud.BatchInsert(tableName, std::move(dataInsert), extendInsert); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} - -/** -* @tc.name: Query001 -* @tc.desc: RdbCloud Query test the cursor is nullptr and code is not E_OK. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, Query001, TestSize.Level1) -{ - std::shared_ptr cursor = nullptr; - std::string tableName = "testTable"; - EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_NETWORK_ERROR, cursor))); - BindAssets snapshots; - RdbCloud rdbCloud(mockCloudDB, snapshots); - auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); - EXPECT_EQ(result, DBStatus::CLOUD_NETWORK_ERROR); -} - -/** -* @tc.name: Query002 -* @tc.desc: RdbCloud Query test code is QUERY_END. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, Query002, TestSize.Level1) -{ - std::shared_ptr mockCursor = std::make_shared(); - std::string tableName = "testTable"; - EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_OK, mockCursor))); - EXPECT_CALL(*mockCursor, GetCount()).WillOnce(Return(COUNT)); - EXPECT_CALL(*mockCursor, GetEntry(_)).WillOnce(Return(E_OK)).WillOnce(Return(E_ERROR)); - EXPECT_CALL(*mockCursor, MoveToNext()).WillRepeatedly(Return(E_OK)); - EXPECT_CALL(*mockCursor, IsEnd()).WillOnce(Return(true)); - - BindAssets snapshots; - RdbCloud rdbCloud(mockCloudDB, snapshots); - auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); - EXPECT_EQ(result, DBStatus::QUERY_END); -} - -/** -* @tc.name: Query003 -* @tc.desc: RdbCloud Query test code is CLOUD_ERROR. -* @tc.type: FUNC -*/ -HWTEST_F(RdbCloudTest, Query003, TestSize.Level1) -{ - std::shared_ptr mockCursor = std::make_shared(); - std::string tableName = "testTable"; - EXPECT_CALL(*mockCloudDB, Query(tableName, _)).WillOnce(Return(std::make_pair(E_OK, mockCursor))); - EXPECT_CALL(*mockCursor, GetCount()).WillOnce(Return(COUNT)); - EXPECT_CALL(*mockCursor, GetEntry(_)).WillOnce(Return(E_OK)).WillOnce(Return(E_ERROR)); - EXPECT_CALL(*mockCursor, MoveToNext()).WillRepeatedly(Return(E_OK)); - EXPECT_CALL(*mockCursor, IsEnd()).WillOnce(Return(false)); - - BindAssets snapshots; - RdbCloud rdbCloud(mockCloudDB, snapshots); - auto result = rdbCloud.Query(tableName, g_DBVBucket, g_DBVBuckets); - EXPECT_EQ(result, DBStatus::CLOUD_ERROR); -} -} // namespace DistributedRDBTest -} // namespace OHOS::Test \ No newline at end of file -- Gitee From c43fa98d3571a173fe61e155a4f010fc84fd6a32 Mon Sep 17 00:00:00 2001 From: weishaoxiong Date: Fri, 29 Aug 2025 10:48:17 +0800 Subject: [PATCH 74/76] fix: Signed-off-by: weishaoxiong --- .../service/cloud/sync_manager.cpp | 5 +- .../service/cloud/sync_manager.h | 8 +- .../service/test/cloud_service_impl_test.cpp | 113 ++++++++++-------- 3 files changed, 69 insertions(+), 57 deletions(-) diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp index ee8fb3b06..ea2bc3db7 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.cpp +++ b/services/distributeddataservice/service/cloud/sync_manager.cpp @@ -1129,10 +1129,7 @@ void SyncManager::NetworkRecoveryManager::OnNetworkConnected() return; } for (auto user : users) { - std::vector syncApps(event->syncApps[user]); - if (timeout) { - syncApps = GetAppList(user); - } + const auto &syncApps = timeout ? GetAppList(user) : event->syncApps[user]; for (const auto &bundleName : syncApps) { ZLOGI("sync start bundleName:%{public}s, user:%{public}d", bundleName.c_str(), user); syncManager_.DoCloudSync(SyncInfo(user, bundleName, "", {}, MODE_ONLINE)); diff --git a/services/distributeddataservice/service/cloud/sync_manager.h b/services/distributeddataservice/service/cloud/sync_manager.h index 443e75022..1e152ca10 100644 --- a/services/distributeddataservice/service/cloud/sync_manager.h +++ b/services/distributeddataservice/service/cloud/sync_manager.h @@ -104,6 +104,10 @@ public: void OnScreenUnlocked(int32_t user); void CleanCompensateSync(int32_t userId); static std::string GetPath(const StoreMetaData &meta); + void OnNetworkDisconnected(); + void OnNetworkConnected(); + +private: class NetworkRecoveryManager { public: explicit NetworkRecoveryManager(SyncManager &syncManager) : syncManager_(syncManager) @@ -123,10 +127,6 @@ public: std::unique_ptr currentEvent_; SyncManager &syncManager_; }; - - void OnNetworkDisconnected(); - void OnNetworkConnected(); -private: using Event = DistributedData::Event; using Task = ExecutorPool::Task; using TaskId = ExecutorPool::TaskId; diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp index bc45b8553..6238c5271 100644 --- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp @@ -83,6 +83,8 @@ public: static void CheckDelMeta(StoreMetaMapping &metaMapping, StoreMetaData &meta, StoreMetaData &meta1); static std::shared_ptr cloudServiceImpl_; static NetworkDelegateMock delegate_; + static auto ReturnWithUserList(const std::vector& users); + protected: static std::shared_ptr dbStoreMock_; static StoreMetaData metaData_; @@ -131,12 +133,22 @@ void CloudServiceImplTest::InitMetaData() metaData_.dataDir = "/test_cloud_service_impl_store"; } +auto CloudServiceImplTest::ReturnWithUserList(const std::vector &users) +{ + return Invoke([=](std::vector &outUsers) -> bool { + outUsers = users; + return true; + }); +} + void CloudServiceImplTest::SetUpTestCase(void) { size_t max = 12; size_t min = 5; auto executor = std::make_shared(max, min); DeviceManagerAdapter::GetInstance().Init(executor); + cloudServiceImpl_->OnBind( + { "CloudServiceImplTest", static_cast(IPCSkeleton::GetSelfTokenID()), std::move(executor) }); Bootstrap::GetInstance().LoadCheckers(); CryptoManager::GetInstance().GenerateRootKey(); MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, ""); @@ -977,38 +989,49 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest001, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); accountDelegateMock = new (std::nothrow) AccountDelegateMock(); - if (accountDelegateMock != nullptr) { - AccountDelegate::instance_ = nullptr; - AccountDelegate::RegisterAccountInstance(accountDelegateMock); - } + ASSERT_NE(accountDelegateMock, nullptr); + AccountDelegate::instance_ = nullptr; + AccountDelegate::RegisterAccountInstance(accountDelegateMock); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); + EXPECT_CALL(*accountDelegateMock, IsVerified(_)).WillRepeatedly(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(ReturnWithUserList({ MOCK_USER })); // 2 means that the QueryForegroundUsers interface will be called twice EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) .Times(2) - .WillRepeatedly(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); - std::string bundleName = "com.ohos.test"; + .WillRepeatedly(ReturnWithUserList({ MOCK_USER })); + EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).WillOnce(Return(MOCK_USER)); + delegate_.isNetworkAvailable_ = false; CloudInfo::AppInfo appInfo; - appInfo.bundleName = bundleName; + appInfo.bundleName = TEST_CLOUD_BUNDLE; + appInfo.cloudSwitch = true; std::map apps; - apps.emplace(bundleName, appInfo); + apps.emplace(TEST_CLOUD_BUNDLE, appInfo); CloudInfo cloudInfo; cloudInfo.apps = apps; cloudInfo.user = MOCK_USER; + cloudInfo.enableCloud = true; MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true); auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); - EXPECT_NE(recoveryManager.currentEvent_, nullptr); - recoveryManager.RecordSyncApps(MOCK_USER, bundleName); - recoveryManager.RecordSyncApps(MOCK_USER, bundleName); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); + + SchemaMeta schemaMeta; + schemaMeta.bundleName = TEST_CLOUD_BUNDLE; + SchemaMeta::Database database; + database.name = TEST_CLOUD_STORE; + schemaMeta.databases.emplace_back(database); + MetaDataManager::GetInstance().SaveMeta(CloudInfo::GetSchemaKey(cloudInfo.user, TEST_CLOUD_BUNDLE), schemaMeta, + true); + CloudData::CloudService::Option option; + option.syncMode = DistributedData::GeneralStore::CLOUD_BEGIN; + auto async = [](const DistributedRdb::Details &details) {}; + cloudServiceImpl_->CloudSync(TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, option, async); + EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).WillOnce(Return(MOCK_USER)); + cloudServiceImpl_->CloudSync(TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, option, async); + sleep(1); EXPECT_EQ(recoveryManager.currentEvent_->syncApps.size(), 1); + delegate_.isNetworkAvailable_ = true; cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); } @@ -1023,6 +1046,7 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest001, TestSize.Level0) HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest002, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsVerified(_)).WillRepeatedly(Return(true)); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { users = { MOCK_USER }; @@ -1031,13 +1055,10 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest002, TestSize.Level0) // 2 means that the QueryForegroundUsers interface will be called twice EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) .Times(2) - .WillRepeatedly(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); + .WillRepeatedly(ReturnWithUserList({ MOCK_USER })); auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); - EXPECT_NE(recoveryManager.currentEvent_, nullptr); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); @@ -1053,13 +1074,16 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest002, TestSize.Level0) HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest003, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsVerified(_)).WillRepeatedly(Return(true)); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); - EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); + EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)).WillOnce(ReturnWithUserList({ MOCK_USER })); auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; - recoveryManager.RecordSyncApps(MOCK_USER, ""); + CloudData::CloudService::Option option; + option.syncMode = DistributedData::GeneralStore::CLOUD_BEGIN; + auto async = [](const DistributedRdb::Details &details) {}; + EXPECT_CALL(*accountDelegateMock, GetUserByToken(_)).WillOnce(Return(MOCK_USER)); + cloudServiceImpl_->CloudSync(TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, option, async); + sleep(1); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); } @@ -1074,30 +1098,26 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest003, TestSize.Level0) HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsVerified(_)).WillRepeatedly(Return(true)); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(ReturnWithUserList({ MOCK_USER })); + cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; - recoveryManager.OnNetworkDisconnected(); ASSERT_NE(recoveryManager.currentEvent_, nullptr); - auto returnWithUserList = - [](const std::vector &users) { - return Invoke([=](std::vector &outUsers) -> bool { - outUsers = users; - return true; - }); - }; EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) - .WillOnce(returnWithUserList({ MOCK_USER })) + .WillOnce(ReturnWithUserList({ MOCK_USER })) .WillOnce(Return(false)); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); - recoveryManager.OnNetworkDisconnected(); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(ReturnWithUserList({ MOCK_USER })); + cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); ASSERT_NE(recoveryManager.currentEvent_, nullptr); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) - .WillOnce(returnWithUserList({ MOCK_USER })) - .WillOnce(returnWithUserList({})); + .WillOnce(ReturnWithUserList({ MOCK_USER })) + .WillOnce(ReturnWithUserList({})); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); } @@ -1112,24 +1132,19 @@ HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest004, TestSize.Level0) HWTEST_F(CloudServiceImplTest, NetworkRecoveryTest005, TestSize.Level0) { ASSERT_NE(cloudServiceImpl_, nullptr); + EXPECT_CALL(*accountDelegateMock, IsVerified(_)).WillRepeatedly(Return(true)); EXPECT_CALL(*accountDelegateMock, IsLoginAccount()).WillOnce(Return(true)); - EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); + EXPECT_CALL(*accountDelegateMock, QueryUsers(_)).WillOnce(ReturnWithUserList({ MOCK_USER })); // 2 means that the QueryForegroundUsers interface will be called twice EXPECT_CALL(*accountDelegateMock, QueryForegroundUsers(_)) .Times(2) - .WillRepeatedly(Invoke([&](std::vector &users) -> bool { - users = { MOCK_USER }; - return true; - })); + .WillRepeatedly(ReturnWithUserList({ MOCK_USER })); CloudInfo cloudInfo; cloudInfo.user = MOCK_USER; MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true); auto &recoveryManager = cloudServiceImpl_->syncManager_.networkRecoveryManager_; cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID); - EXPECT_NE(recoveryManager.currentEvent_, nullptr); + ASSERT_NE(recoveryManager.currentEvent_, nullptr); recoveryManager.currentEvent_->disconnectTime -= std::chrono::hours(DISCONNECT_TIME); cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID); EXPECT_EQ(recoveryManager.currentEvent_, nullptr); -- Gitee From f719316c11998d99eb8760d28b1de8c66452aa94 Mon Sep 17 00:00:00 2001 From: yangliu Date: Fri, 29 Aug 2025 15:21:09 +0800 Subject: [PATCH 75/76] fix Signed-off-by: yangliu --- .../service/kvdb/kvdb_general_store.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp index b825f970c..f18d59547 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp @@ -443,8 +443,8 @@ std::pair KVDBGeneralStore::Sync(const Devices &devices, GenQu dbStatus = delegate_->UnSubscribeRemoteQuery(devices, GetDBSyncCompleteCB(std::move(async)), dbQuery, false); } else if (syncMode < NEARBY_END) { - DeviceSyncOption syncOption = { .devices = devices, .mode = dbMode, .query = dbQuery, .isWait = false, - .isRetry = syncParam.isRetry }; + DeviceSyncOption syncOption = { .devices = devices, .mode = dbMode, .isQuery = !kvQuery->IsEmpty(), + .query = dbQuery, .isWait = false, .isRetry = syncParam.isRetry }; dbStatus = delegate_->Sync(syncOption, GetDBSyncCompleteCB(std::move(async))); } else { ZLOGE("Err sync mode! sync mode:%{public}d", syncMode); -- Gitee From ad7d07c47b9e238fa318643c45263c0f052e23e5 Mon Sep 17 00:00:00 2001 From: xuyunan Date: Sat, 30 Aug 2025 15:43:27 +0800 Subject: [PATCH 76/76] fix db_delegate starttimer if-encrypt path Signed-off-by: xuyunan --- .../service/data_share/common/db_delegate.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/distributeddataservice/service/data_share/common/db_delegate.cpp b/services/distributeddataservice/service/data_share/common/db_delegate.cpp index 9e77bcbb4..2915b83f8 100644 --- a/services/distributeddataservice/service/data_share/common/db_delegate.cpp +++ b/services/distributeddataservice/service/data_share/common/db_delegate.cpp @@ -145,9 +145,9 @@ void DBDelegate::StartTimer(bool encrypt) dstTaskIdTemp = Executor::INVALID_TASK_ID; }; if (encrypt) { - stores_.DoActionIfEmpty(task); - } else { storesEncrypt_.DoActionIfEmpty(task); + } else { + stores_.DoActionIfEmpty(task); } }, std::chrono::seconds(INTERVAL), std::chrono::seconds(INTERVAL)); -- Gitee