diff --git a/test/fuzztest/BUILD.gn b/test/fuzztest/BUILD.gn index c425737d91a2c74cb97f725954a8b2c0042af77f..9ba1a94ea00a7e69c1e5bd2146a00d6a0792ee4e 100644 --- a/test/fuzztest/BUILD.gn +++ b/test/fuzztest/BUILD.gn @@ -53,5 +53,6 @@ group("fuzztest") { "dbinder/dbinder_service/src/getlocaldeviceid_fuzzer:GetLocalDeviceIDFuzzTest", "dbinder/dbinder_service/src/getseqnumber_fuzzer:GetSeqNumberFuzzTest", "dbinder/dbinder_service/src/restartremotelistener_fuzzer:ReStartRemoteListenerFuzzTest", + "dbinder/dbinder_service/src/dbinderservicenew_fuzzer:DBinderServiceNewFuzzTest", ] } diff --git a/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/BUILD.gn b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..f885aae669d5672c4436ea7d183584104b90cbef --- /dev/null +++ b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/BUILD.gn @@ -0,0 +1,33 @@ +# 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") + +##############################fuzztest########################################## +ohos_fuzztest("DBinderServiceNewFuzzTest") { + module_out_path = "ipc/ipc" + fuzz_config_file = "../dbinderservicenew_fuzzer" + defines = [ + "private = public", + "protected = public", + ] + sources = [ "dbinderservicenew_fuzzer.cpp" ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "ipc:libdbinder", + "ipc:ipc_core", + ] +} diff --git a/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/corpus/init b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..7ade8a0faafeaedba7241e7d4a97b8e1f9691932 --- /dev/null +++ b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/corpus/init @@ -0,0 +1,16 @@ +/* + * 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. + */ + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.cpp b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5e833f9fede7900a08448cdc0f5348951a34b4f0 --- /dev/null +++ b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.cpp @@ -0,0 +1,635 @@ +/* + * 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 "dbinderservicenew_fuzzer.h" + +#include +#include +#include +#include "dbinder_service.h" +#include "dbinder_service_stub.h" +#include "string_ex.h" + +namespace OHOS { + class TestRpcSystemAbilityCallback : public RpcSystemAbilityCallback { + public: + sptr GetSystemAbilityFromRemote(int32_t systemAbilityId) override + { + return nullptr; + } + + bool LoadSystemAbilityFromRemote(const std::string& srcNetworkId, int32_t systemAbilityId) override + { + return isLoad_; + } + bool IsDistributedSystemAbility(int32_t systemAbilityId) override + { + return isSystemAbility_; + } + bool isSystemAbility_ = true; + bool isLoad_ = true; + }; + + void OnRemoteMessageTaskTest(FuzzedDataProvider &provider) + { + std::shared_ptr handleEntry = std::make_shared(); + if (handleEntry == nullptr) { + return; + } + handleEntry->head.len = sizeof(DHandleEntryTxRx); + handleEntry->head.version = provider.ConsumeIntegral(); + handleEntry->dBinderCode = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.OnRemoteMessageTask(handleEntry); + handleEntry->dBinderCode = DBinderCode::MESSAGE_AS_INVOKER; + dBinderService.OnRemoteMessageTask(handleEntry); + handleEntry->dBinderCode = DBinderCode::MESSAGE_AS_OBITUARY; + dBinderService.OnRemoteMessageTask(handleEntry); + } + + void StartDBinderServiceTest(FuzzedDataProvider &provider) + { + OHOS::DBinderService dBinderService; + std::shared_ptr callbackImpl = nullptr; + dBinderService.StartDBinderService(callbackImpl); + callbackImpl = std::make_shared(); + if (callbackImpl == nullptr) { + return; + } + int32_t systemAbilityId = provider.ConsumeIntegral(); + callbackImpl->IsDistributedSystemAbility(systemAbilityId); + + dBinderService.StartDBinderService(callbackImpl); + } + + void AddStubByTagTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + binder_uintptr_t binderObjectPtr = reinterpret_cast(stub.GetRefPtr()); + OHOS::DBinderService dBinderService; + dBinderService.AddStubByTag(binderObjectPtr); + } + + void CheckBinderObject1Test(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + binder_uintptr_t binderObjectPtr = reinterpret_cast(stub.GetRefPtr()); + OHOS::DBinderService dBinderService; + dBinderService.CheckBinderObject(stub, binderObjectPtr); + } + + void CheckBinderObject2Test(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.CheckBinderObject(stub, binderObject); + } + + void HasDBinderStubTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + binder_uintptr_t binderObjectPtr = reinterpret_cast(stub.GetRefPtr()); + OHOS::DBinderService dBinderService; + dBinderService.HasDBinderStub(binderObjectPtr); + } + + void IsSameStubObject1Test(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + std::u16string service = Str8ToStr16(serviceName); + OHOS::DBinderService dBinderService; + dBinderService.IsSameStubObject(stub, service, deviceID); + } + + void IsSameStubObject2Test(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + sptr stub = nullptr; + std::u16string service = Str8ToStr16(serviceName); + OHOS::DBinderService dBinderService; + dBinderService.IsSameStubObject(stub, service, deviceID); + } + + void FindDBinderStubTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string device = provider.ConsumeRandomLengthString(); + std::u16string service = Str8ToStr16(serviceName); + OHOS::DBinderService dBinderService; + dBinderService.FindDBinderStub(service, device); + } + + void DeleteDBinderStubTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string device = provider.ConsumeRandomLengthString(); + std::u16string service = Str8ToStr16(serviceName); + OHOS::DBinderService dBinderService; + dBinderService.DeleteDBinderStub(service, device); + } + + void FindOrNewDBinderStubTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string device = provider.ConsumeRandomLengthString(); + std::u16string service = Str8ToStr16(serviceName); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + OHOS::DBinderService dBinderService; + dBinderService.FindOrNewDBinderStub(service, device, binderObject); + } + + void FindOrNewConcurrentLockInfoTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + bool isNew; + OHOS::DBinderService dBinderService; + dBinderService.FindOrNewConcurrentLockInfo(stub, isNew); + } + + void MakeRemoteBinderInnerTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + std::u16string service = Str8ToStr16(serviceName); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + uint32_t pid = provider.ConsumeIntegral(); + uint32_t uid = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.MakeRemoteBinderInner(stub, service, deviceID, pid, uid); + } + + void MakeRemoteBinderTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + std::u16string service = Str8ToStr16(serviceName); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + uint32_t pid = provider.ConsumeIntegral(); + uint32_t uid = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.MakeRemoteBinder(service, deviceID, binderObject, pid, uid); + } + + void CheckDeviceIDsInvalidTest(FuzzedDataProvider &provider) + { + std::string deviceID = provider.ConsumeRandomLengthString(); + std::string localDevID = provider.ConsumeRandomLengthString(); + OHOS::DBinderService dBinderService; + dBinderService.CheckDeviceIDsInvalid(deviceID, localDevID); + } + + void CopyDeviceIDsToMessageTest(FuzzedDataProvider &provider) + { + std::string deviceID = provider.ConsumeRandomLengthString(); + std::string localDevID = provider.ConsumeRandomLengthString(); + auto message = std::make_shared(); + if (message == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.CopyDeviceIDsToMessage(message, localDevID, deviceID); + } + + void CreateMessageTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + uint32_t seqNumber = provider.ConsumeIntegral(); + uint32_t pid = provider.ConsumeIntegral(); + uint32_t uid = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.CreateMessage(stub, seqNumber, pid, uid); + } + + void SendEntryToRemoteTest(FuzzedDataProvider &provider) + { + OHOS::DBinderService dBinderService; + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + uint32_t seqNumber = provider.ConsumeIntegral(); + uint32_t pid = provider.ConsumeIntegral(); + uint32_t uid = provider.ConsumeIntegral(); + dBinderService.SendEntryToRemote(stub, seqNumber, pid, uid); + } + + void InvokerRemoteDBinderTest(FuzzedDataProvider &provider) + { + std::string serviceName = provider.ConsumeRandomLengthString(); + std::string deviceID = provider.ConsumeRandomLengthString(); + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + sptr stub = new (std::nothrow) DBinderServiceStub(serviceName, deviceID, binderObject); + if (stub == nullptr) { + return; + } + uint32_t seqNumber = provider.ConsumeIntegral(); + uint32_t pid = provider.ConsumeIntegral(); + uint32_t uid = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.InvokerRemoteDBinder(stub, seqNumber, pid, uid); + } + + void CheckSystemAbilityIdTest(FuzzedDataProvider &provider) + { + int32_t systemAbilityId = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.CheckSystemAbilityId(systemAbilityId); + } + + void IsSameLoadSaItemTest(FuzzedDataProvider &provider) + { + std::string srcNetworkId = provider.ConsumeRandomLengthString(); + int32_t systemAbilityId = provider.ConsumeIntegral(); + std::shared_ptr loadSaItem = std::make_shared(); + if (loadSaItem == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.IsSameLoadSaItem(srcNetworkId, systemAbilityId, loadSaItem); + } + + void PopLoadSaItemTest(FuzzedDataProvider &provider) + { + std::string srcNetworkId = provider.ConsumeRandomLengthString(); + int32_t systemAbilityId = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.PopLoadSaItem(srcNetworkId, systemAbilityId); + } + + void LoadSystemAbilityComplete1Test(FuzzedDataProvider &provider) + { + std::string srcNetworkId = provider.ConsumeRandomLengthString(); + int handle = provider.ConsumeIntegral(); + sptr remoteObject = new (std::nothrow) IPCObjectProxy(handle); + if (remoteObject == nullptr) { + return; + } + int32_t systemAbilityId = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject); + } + + void LoadSystemAbilityComplete2Test(FuzzedDataProvider &provider) + { + std::string srcNetworkId = provider.ConsumeRandomLengthString(); + sptr remoteObject = nullptr; + int32_t systemAbilityId = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject); + } + + void CheckAndAmendSaIdTest(FuzzedDataProvider &provider) + { + auto message = std::make_shared(); + if (message == nullptr) { + return; + } + message->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.CheckAndAmendSaId(message); + } + + void OnRemoteInvokerMessageTest(FuzzedDataProvider &provider) + { + auto message = std::make_shared(); + if (message == nullptr) { + return; + } + message->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.OnRemoteInvokerMessage(message); + } + + void CreateDatabusNameTest(FuzzedDataProvider &provider) + { + int uid = provider.ConsumeIntegral(); + int pid = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.CreateDatabusName(uid, pid); + } + + void CheckDeviceIdIllegalTest(FuzzedDataProvider &provider) + { + std::string remoteDeviceId = provider.ConsumeRandomLengthString(); + OHOS::DBinderService dBinderService; + dBinderService.CheckDeviceIdIllegal(remoteDeviceId); + } + + void CheckSessionNameIsEmptyTest(FuzzedDataProvider &provider) + { + std::string sessionName = provider.ConsumeRandomLengthString(); + OHOS::DBinderService dBinderService; + dBinderService.CheckSessionNameIsEmpty(sessionName); + } + + void CheckInvokeListenThreadIllegalTest(FuzzedDataProvider &provider) + { + std::string sessionName = provider.ConsumeRandomLengthString(); + int handle = provider.ConsumeIntegral(); + sptr proxy = new (std::nothrow) IPCObjectProxy(handle); + if (proxy == nullptr) { + return; + } + MessageParcel parcel; + MessageParcel reply; + OHOS::DBinderService dBinderService; + dBinderService.CheckInvokeListenThreadIllegal(proxy, parcel, reply); + } + + void CheckStubIndexAndSessionNameIllegalTest(FuzzedDataProvider &provider) + { + uint64_t stubIndex = provider.ConsumeIntegral(); + std::string serverSessionName = provider.ConsumeRandomLengthString(); + std::string deviceId = provider.ConsumeRandomLengthString(); + int handle = provider.ConsumeIntegral(); + sptr proxy = new (std::nothrow) IPCObjectProxy(handle); + if (proxy == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.CheckStubIndexAndSessionNameIllegal(stubIndex, serverSessionName, deviceId, proxy); + } + + void SetReplyMessageTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + uint64_t stubIndex = provider.ConsumeIntegral(); + std::string serverSessionName = provider.ConsumeRandomLengthString(); + uint32_t selfTokenId = provider.ConsumeIntegral(); + int handle = provider.ConsumeIntegral(); + sptr proxy = new (std::nothrow) IPCObjectProxy(handle); + if (proxy == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.SetReplyMessage(replyMessage, stubIndex, serverSessionName, selfTokenId, proxy); + } + + void OnRemoteInvokerDataBusMessageTest(FuzzedDataProvider &provider) + { + int handle = provider.ConsumeIntegral(); + sptr proxy = new (std::nothrow) IPCObjectProxy(handle); + if (proxy == nullptr) { + return; + } + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + std::string remoteDeviceId = provider.ConsumeRandomLengthString(); + int pid = provider.ConsumeIntegral(); + int uid = provider.ConsumeIntegral(); + uint32_t tokenId = provider.ConsumeIntegral(); + + OHOS::DBinderService dBinderService; + dBinderService.OnRemoteInvokerDataBusMessage(proxy, replyMessage, remoteDeviceId, pid, uid, tokenId); + } + + void GetRegisterServiceTest(FuzzedDataProvider &provider) + { + binder_uintptr_t binderObject = static_cast(provider.ConsumeIntegral()); + OHOS::DBinderService dBinderService; + dBinderService.GetRegisterService(binderObject); + } + + void RegisterRemoteProxyTest(FuzzedDataProvider &provider) + { + std::string service = provider.ConsumeRandomLengthString(); + std::u16string serviceName = Str8ToStr16(service); + int handle = provider.ConsumeIntegral(); + sptr binderObject = new (std::nothrow) IPCObjectProxy(handle); + if (binderObject == nullptr) { + return; + } + OHOS::DBinderService dBinderService; + dBinderService.RegisterRemoteProxy(serviceName, binderObject); + } + + void ProcessOnSessionClosedTest(FuzzedDataProvider &provider) + { + std::string networkId = provider.ConsumeRandomLengthString(); + OHOS::DBinderService dBinderService; + dBinderService.ProcessOnSessionClosed(networkId); + } + + void OnRemoteErrorMessageTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.OnRemoteErrorMessage(replyMessage); + } + + void OnRemoteReplyMessageTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.OnRemoteReplyMessage(replyMessage); + } + + void IsSameSessionTest(FuzzedDataProvider &provider) + { + std::shared_ptr oldSession = std::make_shared(); + std::shared_ptr newSession = std::make_shared(); + if (oldSession == nullptr && newSession == nullptr) { + return; + } + oldSession->type = provider.ConsumeIntegral(); + newSession->type = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.IsSameSession(oldSession, newSession); + } + + void IsInvalidStubTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.IsInvalidStub(replyMessage); + } + + void IsValidSessionNameTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.IsValidSessionName(replyMessage); + } + + void CopyDeviceIdInfoTest(FuzzedDataProvider &provider) + { + std::shared_ptr session = std::make_shared(); + std::shared_ptr replyMessage = std::make_shared(); + if (session == nullptr && replyMessage == nullptr) { + return; + } + session->type = provider.ConsumeIntegral(); + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.CopyDeviceIdInfo(session, replyMessage); + } + + void InitializeSessionTest(FuzzedDataProvider &provider) + { + std::shared_ptr session = std::make_shared(); + std::shared_ptr replyMessage = std::make_shared(); + if (session == nullptr && replyMessage == nullptr) { + return; + } + session->type = provider.ConsumeIntegral(); + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.InitializeSession(session, replyMessage); + } + + void MakeSessionByReplyMessageTest(FuzzedDataProvider &provider) + { + std::shared_ptr replyMessage = std::make_shared(); + if (replyMessage == nullptr) { + return; + } + replyMessage->transType = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.MakeSessionByReplyMessage(replyMessage); + } + + void WakeupThreadByStubTest(FuzzedDataProvider &provider) + { + uint32_t seqNumber = provider.ConsumeIntegral(); + OHOS::DBinderService dBinderService; + dBinderService.WakeupThreadByStub(seqNumber); + } +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + FuzzedDataProvider provider(data, size); + OHOS::OnRemoteMessageTaskTest(provider); + OHOS::StartDBinderServiceTest(provider); + OHOS::AddStubByTagTest(provider); + OHOS::CheckBinderObject1Test(provider); + OHOS::CheckBinderObject2Test(provider); + OHOS::HasDBinderStubTest(provider); + OHOS::IsSameStubObject1Test(provider); + OHOS::IsSameStubObject2Test(provider); + OHOS::FindDBinderStubTest(provider); + OHOS::DeleteDBinderStubTest(provider); + OHOS::FindOrNewDBinderStubTest(provider); + OHOS::FindOrNewConcurrentLockInfoTest(provider); + OHOS::MakeRemoteBinderInnerTest(provider); + OHOS::MakeRemoteBinderTest(provider); + OHOS::CheckDeviceIDsInvalidTest(provider); + OHOS::CopyDeviceIDsToMessageTest(provider); + OHOS::CreateMessageTest(provider); + OHOS::SendEntryToRemoteTest(provider); + OHOS::InvokerRemoteDBinderTest(provider); + OHOS::CheckSystemAbilityIdTest(provider); + OHOS::IsSameLoadSaItemTest(provider); + OHOS::PopLoadSaItemTest(provider); + OHOS::LoadSystemAbilityComplete1Test(provider); + OHOS::LoadSystemAbilityComplete2Test(provider); + OHOS::CheckAndAmendSaIdTest(provider); + OHOS::OnRemoteInvokerMessageTest(provider); + OHOS::CreateDatabusNameTest(provider); + OHOS::CheckDeviceIdIllegalTest(provider); + OHOS::CheckSessionNameIsEmptyTest(provider); + OHOS::CheckInvokeListenThreadIllegalTest(provider); + OHOS::CheckStubIndexAndSessionNameIllegalTest(provider); + OHOS::SetReplyMessageTest(provider); + OHOS::OnRemoteInvokerDataBusMessageTest(provider); + OHOS::GetRegisterServiceTest(provider); + OHOS::RegisterRemoteProxyTest(provider); + OHOS::ProcessOnSessionClosedTest(provider); + OHOS::OnRemoteErrorMessageTest(provider); + OHOS::OnRemoteReplyMessageTest(provider); + OHOS::IsSameSessionTest(provider); + OHOS::IsInvalidStubTest(provider); + OHOS::IsValidSessionNameTest(provider); + OHOS::CopyDeviceIdInfoTest(provider); + OHOS::InitializeSessionTest(provider); + OHOS::MakeSessionByReplyMessageTest(provider); + OHOS::WakeupThreadByStubTest(provider); + return 0; +} diff --git a/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.h b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.h new file mode 100644 index 0000000000000000000000000000000000000000..12880f6f8412ffd4c2de28d407df3d47341a4013 --- /dev/null +++ b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/dbinderservicenew_fuzzer.h @@ -0,0 +1,27 @@ +/* + * 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 DBINDERSERVICENEW_FUZZER_H +#define DBINDERSERVICENEW_FUZZER_H + +#include +#include +#include +#include +#include +#include + +#define FUZZ_PROJECT_NAME "dbinderservicenew_fuzzer" + +#endif \ No newline at end of file diff --git a/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/project.xml b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/dbinder/dbinder_service/src/dbinderservicenew_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + +