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 "samgrdumper_fuzzer.h"
17
18 #define private public
19 #include "system_ability_manager.h"
20 #include "system_ability_manager_dumper.h"
21 #include "schedule/system_ability_state_scheduler.h"
22 #include "sam_mock_permission.h"
23
24 namespace OHOS {
25 namespace Samgr {
26 namespace {
27 constexpr size_t THRESHOLD = 10;
28 constexpr const char* HIDUMPER_PROCESS_NAME = "hidumper_service";
29 }
30
BuildInt32FromData(const uint8_t * data,size_t size)31 int32_t BuildInt32FromData(const uint8_t* data, size_t size)
32 {
33 if ((data == nullptr) || (size < sizeof(int32_t))) {
34 return 0;
35 }
36 int32_t int32Val = *reinterpret_cast<const int32_t *>(data);
37 return int32Val;
38 }
39
BuildStringFromData(const uint8_t * data,size_t size)40 std::string BuildStringFromData(const uint8_t* data, size_t size)
41 {
42 if ((data == nullptr) || (size == 0)) {
43 return "";
44 }
45 std::string strVal(reinterpret_cast<const char *>(data), size);
46 return strVal;
47 }
48
SamgrDumperFuzzTest(const uint8_t * data,size_t size)49 void SamgrDumperFuzzTest(const uint8_t* data, size_t size)
50 {
51 SamMockPermission::MockProcess(HIDUMPER_PROCESS_NAME);
52 std::string strVal = BuildStringFromData(data, size);
53 std::vector<std::string> args;
54 SplitStr(strVal, " ", args);
55 std::vector<std::u16string> argsWithStr16;
56 for (size_t i = 0; i < args.size(); i++) {
57 argsWithStr16.emplace_back(Str8ToStr16(args[i]));
58 }
59 std::string result;
60 std::shared_ptr<SystemAbilityStateScheduler> scheduler = std::make_shared<SystemAbilityStateScheduler>();
61 int32_t fd = -1;
62 SystemAbilityManagerDumper::FfrtDumpProc(scheduler, fd, args);
63 SystemAbilityManagerDumper::Dump(scheduler, args, result);
64 int32_t cmd = -1;
65 SystemAbilityManagerDumper::IpcDumpCmdParser(cmd, args);
66 std::string processName = BuildStringFromData(data, size);
67 SystemAbilityManagerDumper::IpcDumpIsSamgr(processName);
68 SystemAbilityManagerDumper::IpcDumpIsAllProcess(processName);
69 SystemAbilityManagerDumper::GetSamgrIpcStatistics(result);
70 SystemAbilityManagerDumper::StopSamgrIpcStatistics(result);
71 SystemAbilityManagerDumper::StartSamgrIpcStatistics(result);
72 SystemAbilityManagerDumper::GetFfrtDumpInfoProc(scheduler, args, result);
73 SystemAbilityManagerDumper::GetSAMgrFfrtInfo(result);
74 int32_t pid = BuildInt32FromData(data, size);
75 SystemAbilityManagerDumper::DumpFfrtInfoByProcName(pid, Str8ToStr16(processName), result);
76
77 std::shared_ptr<SystemAbilityManager> manager = std::make_shared<SystemAbilityManager>();
78 manager->abilityStateScheduler_ = std::make_shared<SystemAbilityStateScheduler>();
79 manager->Dump(fd, argsWithStr16);
80 manager->IpcDumpProc(fd, args);
81 manager->IpcDumpAllProcess(fd, cmd);
82 manager->IpcDumpSamgrProcess(fd, cmd);
83 manager->IpcDumpSingleProcess(fd, cmd, processName);
84 }
85 }
86 }
87
88 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)89 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
90 {
91 if (size < OHOS::Samgr::THRESHOLD) {
92 return 0;
93 }
94
95 OHOS::Samgr::SamgrDumperFuzzTest(data, size);
96
97 return 0;
98 }
99
100