/* * 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. */ #include "missionlistmanagerfourth_fuzzer.h" #include #include #define private public #include "mission_info_mgr.h" #include "mission_list_manager.h" #undef private #include "ability_record.h" using namespace OHOS::AAFwk; using namespace OHOS::AppExecFwk; namespace OHOS { namespace { constexpr size_t FOO_MAX_LEN = 1024; constexpr size_t U32_AT_SIZE = 4; constexpr uint8_t ENABLE = 2; class MyAbilityConnection : public IAbilityConnection { public: MyAbilityConnection() = default; virtual ~MyAbilityConnection() = default; void OnAbilityConnectDone(const AppExecFwk::ElementName &element, const sptr &remoteObject, int resultCode) override {} void OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) override {} sptr AsObject() override { return {}; } }; } // namespace uint32_t GetU32Data(const char *ptr) { // convert fuzz input data to an integer return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]; } std::shared_ptr GetFuzzAbilityRecord() { sptr token = nullptr; AbilityRequest abilityRequest; abilityRequest.appInfo.bundleName = "com.example.fuzzTest"; abilityRequest.abilityInfo.name = "MainAbility"; abilityRequest.abilityInfo.type = AbilityType::DATA; std::shared_ptr abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); if (!abilityRecord) { return nullptr; } return abilityRecord; } sptr GetFuzzAbilityToken() { sptr token = nullptr; std::shared_ptr abilityRecord = GetFuzzAbilityRecord(); if (abilityRecord) { token = abilityRecord->GetToken(); } return token; } bool DoSomethingInterestingWithMyAPI(const char *data, size_t size) { bool boolParam = *data % ENABLE; int intParam = static_cast(GetU32Data(data)); Parcel wantParcel; Want *want = nullptr; if (wantParcel.WriteBuffer(data, size)) { want = Want::Unmarshalling(wantParcel); if (!want) { return false; } } std::shared_ptr abilityRecord = GetFuzzAbilityRecord(); sptr token = GetFuzzAbilityToken(); auto missionListManager = std::make_shared(intParam); auto launcherList = std::make_shared(MissionListType::LAUNCHER); missionListManager->launcherList_ = launcherList; missionListManager->defaultStandardList_ = std::make_shared(MissionListType::DEFAULT_STANDARD); missionListManager->defaultSingleList_ = std::make_shared(MissionListType::DEFAULT_SINGLE); missionListManager->currentMissionLists_.push_front(launcherList); if (!missionListManager->listenerController_) { missionListManager->listenerController_ = std::make_shared(); } DelayedSingleton::GetInstance()->taskDataPersistenceMgr_ = DelayedSingleton::GetInstance(); std::shared_ptr missionList = std::make_shared(); missionListManager->TerminateAbilityLocked(abilityRecord, boolParam); missionListManager->RemoveTerminatingAbility(abilityRecord, boolParam); missionListManager->RemoveMissionList(missionList); missionListManager->DispatchTerminate(abilityRecord); missionListManager->DelayCompleteTerminate(abilityRecord); missionListManager->CompleteTerminate(abilityRecord); missionListManager->CompleteTerminateAndUpdateMission(abilityRecord); missionListManager->GetAbilityFromTerminateList(token); missionListManager->SetMissionLockedState(intParam, boolParam); if (want) { delete want; want = nullptr; } return true; } } // namespace OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { /* Run your code on data */ if (data == nullptr) { return 0; } /* Validate the length of size */ if (size < OHOS::U32_AT_SIZE || size > OHOS::FOO_MAX_LEN) { return 0; } char *ch = (char *)malloc(size + 1); if (ch == nullptr) { std::cout << "malloc failed." << std::endl; return 0; } (void)memset_s(ch, size + 1, 0x00, size + 1); if (memcpy_s(ch, size, data, size) != EOK) { std::cout << "copy failed." << std::endl; free(ch); ch = nullptr; return 0; } OHOS::DoSomethingInterestingWithMyAPI(ch, size); free(ch); ch = nullptr; return 0; }