1/* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "abilityautostartupservicea_fuzzer.h" 17 18#include <cstddef> 19#include <cstdint> 20 21#define private public 22#define protected public 23#include "ability_auto_startup_service.h" 24#undef protected 25#undef private 26 27#include "ability_record.h" 28 29using namespace OHOS::AAFwk; 30using namespace OHOS::AppExecFwk; 31using namespace OHOS::AbilityRuntime; 32 33namespace OHOS { 34namespace { 35constexpr int INPUT_ZERO = 0; 36constexpr int INPUT_ONE = 1; 37constexpr int INPUT_THREE = 3; 38constexpr size_t FOO_MAX_LEN = 1024; 39constexpr size_t U32_AT_SIZE = 4; 40constexpr uint8_t ENABLE = 2; 41constexpr size_t OFFSET_ZERO = 24; 42constexpr size_t OFFSET_ONE = 16; 43constexpr size_t OFFSET_TWO = 8; 44} 45 46uint32_t GetU32Data(const char* ptr) 47{ 48 // convert fuzz input data to an integer 49 return (ptr[INPUT_ZERO] << OFFSET_ZERO) | (ptr[INPUT_ONE] << OFFSET_ONE) | (ptr[ENABLE] << OFFSET_TWO) | 50 ptr[INPUT_THREE]; 51} 52 53sptr<Token> GetFuzzAbilityToken() 54{ 55 sptr<Token> token = nullptr; 56 AbilityRequest abilityRequest; 57 abilityRequest.appInfo.bundleName = "com.example.fuzzTest"; 58 abilityRequest.abilityInfo.name = "MainAbility"; 59 abilityRequest.abilityInfo.type = AbilityType::DATA; 60 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); 61 if (abilityRecord) { 62 token = abilityRecord->GetToken(); 63 } 64 return token; 65} 66 67void AbilityStartupServiceFuzztest(bool boolParam, std::string &stringParam, int32_t int32Param) 68{ 69 std::shared_ptr<AbilityAutoStartupService> service = std::make_shared<AbilityAutoStartupService>(); 70 sptr<IRemoteObject> token1 = GetFuzzAbilityToken(); 71 service->RegisterAutoStartupSystemCallback(token1); // branch 72 service->RegisterAutoStartupSystemCallback(token1); // branch duplicate regist 73 service->UnregisterAutoStartupSystemCallback(token1); // branch 74 sptr<IRemoteObject> token2 = GetFuzzAbilityToken(); 75 service->UnregisterAutoStartupSystemCallback(token2); // branch unregister not exist. 76 77 AutoStartupInfo info; 78 info.bundleName = "com.example.fuzzTest"; 79 info.moduleName = "stringParam"; 80 info.abilityName = "MainAbility"; 81 info.appCloneIndex = int32Param; 82 info.accessTokenId = "accessTokenId"; 83 info.userId = int32Param; 84 service->SetApplicationAutoStartup(info); 85 service->InnerSetApplicationAutoStartup(info); 86 service->CancelApplicationAutoStartup(info); 87 88 std::vector<AutoStartupInfo> vecs; 89 vecs.emplace_back(info); 90 service->QueryAllAutoStartupApplications(vecs, int32Param); 91 service->QueryAllAutoStartupApplicationsWithoutPermission(vecs, int32Param); 92 service->DeleteAutoStartupData(stringParam, int32Param); 93 service->CheckAutoStartupData(stringParam, int32Param); 94 service->ExecuteCallbacks(boolParam, info); 95} 96 97bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) 98{ 99 bool boolParam = *data % ENABLE; 100 std::string stringParam(data, size); 101 int32_t int32Param = static_cast<int32_t>(GetU32Data(data)); 102 AbilityStartupServiceFuzztest(boolParam, stringParam, int32Param); 103 return true; 104} 105} 106 107/* Fuzzer entry point */ 108extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) 109{ 110 /* Run your code on data */ 111 if (data == nullptr) { 112 return 0; 113 } 114 115 /* Validate the length of size */ 116 if (size < OHOS::U32_AT_SIZE || size > OHOS::FOO_MAX_LEN) { 117 return 0; 118 } 119 120 char* ch = (char*)malloc(size + 1); 121 if (ch == nullptr) { 122 std::cout << "malloc failed." << std::endl; 123 return 0; 124 } 125 126 (void)memset_s(ch, size + 1, 0x00, size + 1); 127 if (memcpy_s(ch, size, data, size) != EOK) { 128 std::cout << "copy failed." << std::endl; 129 free(ch); 130 ch = nullptr; 131 return 0; 132 } 133 134 OHOS::DoSomethingInterestingWithMyAPI(ch, size); 135 free(ch); 136 ch = nullptr; 137 return 0; 138} 139 140