1 /*
2 * Copyright (c) 2022 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 "setshowname_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <thread>
21
22 #define private public
23 #include "addcoreservicetoken_fuzzer.h"
24 #include "core_service.h"
25 #include "core_service_stub.h"
26 #include "napi_util.h"
27 #include "string_ex.h"
28 #include "system_ability_definition.h"
29 #include "unistd.h"
30
31 using namespace OHOS::Telephony;
32 namespace OHOS {
33 static bool g_isInited = false;
34 constexpr int32_t SLOT_NUM = 2;
35 constexpr int32_t SLEEP_TIME_SECONDS = 10;
36
IsServiceInited()37 bool IsServiceInited()
38 {
39 if (!g_isInited) {
40 auto onStart = [] { DelayedSingleton<CoreService>::GetInstance()->OnStart(); };
41 std::thread startThread(onStart);
42 startThread.join();
43
44 sleep(SLEEP_TIME_SECONDS);
45 if (DelayedSingleton<CoreService>::GetInstance()->GetServiceRunningState() ==
46 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING)) {
47 g_isInited = true;
48 }
49 }
50 return g_isInited;
51 }
52
GetShowName(const uint8_t * data,size_t size)53 void GetShowName(const uint8_t *data, size_t size)
54 {
55 if (!IsServiceInited()) {
56 return;
57 }
58
59 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
60 MessageParcel dataMessageParcel;
61 dataMessageParcel.WriteInt32(slotId);
62 size_t dataSize = size - sizeof(int32_t);
63 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
64 dataMessageParcel.RewindRead(0);
65 MessageParcel reply;
66 DelayedSingleton<CoreService>::GetInstance()->OnGetShowName(dataMessageParcel, reply);
67 }
68
GetSimSpn(const uint8_t * data,size_t size)69 void GetSimSpn(const uint8_t *data, size_t size)
70 {
71 if (!IsServiceInited()) {
72 return;
73 }
74
75 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
76 MessageParcel dataMessageParcel;
77 dataMessageParcel.WriteInt32(slotId);
78 size_t dataSize = size - sizeof(int32_t);
79 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
80 dataMessageParcel.RewindRead(0);
81 MessageParcel reply;
82 DelayedSingleton<CoreService>::GetInstance()->OnGetSimSpn(dataMessageParcel, reply);
83 }
84
GetSimIccId(const uint8_t * data,size_t size)85 void GetSimIccId(const uint8_t *data, size_t size)
86 {
87 if (!IsServiceInited()) {
88 return;
89 }
90
91 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
92 MessageParcel dataMessageParcel;
93 dataMessageParcel.WriteInt32(slotId);
94 size_t dataSize = size - sizeof(int32_t);
95 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
96 dataMessageParcel.RewindRead(0);
97 MessageParcel reply;
98 DelayedSingleton<CoreService>::GetInstance()->OnGetSimIccId(dataMessageParcel, reply);
99 }
100
GetIMSI(const uint8_t * data,size_t size)101 void GetIMSI(const uint8_t *data, size_t size)
102 {
103 if (!IsServiceInited()) {
104 return;
105 }
106
107 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
108 MessageParcel dataMessageParcel;
109 dataMessageParcel.WriteInt32(slotId);
110 size_t dataSize = size - sizeof(int32_t);
111 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
112 dataMessageParcel.RewindRead(0);
113 MessageParcel reply;
114 DelayedSingleton<CoreService>::GetInstance()->OnGetIMSI(dataMessageParcel, reply);
115 }
116
IsSimActive(const uint8_t * data,size_t size)117 void IsSimActive(const uint8_t *data, size_t size)
118 {
119 if (!IsServiceInited()) {
120 return;
121 }
122
123 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
124 MessageParcel dataMessageParcel;
125 dataMessageParcel.WriteInt32(slotId);
126 size_t dataSize = size - sizeof(int32_t);
127 dataMessageParcel.WriteBuffer(data + sizeof(int32_t), dataSize);
128 dataMessageParcel.RewindRead(0);
129 MessageParcel reply;
130 DelayedSingleton<CoreService>::GetInstance()->OnIsSimActive(dataMessageParcel, reply);
131 }
132
SetShowName(const uint8_t * data,size_t size)133 void SetShowName(const uint8_t *data, size_t size)
134 {
135 if (!IsServiceInited()) {
136 return;
137 }
138 int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
139 std::string message(reinterpret_cast<const char *>(data), size);
140 MessageParcel dataMessageParcel;
141 dataMessageParcel.WriteInt32(slotId);
142 dataMessageParcel.WriteString16(Str8ToStr16(message));
143 dataMessageParcel.RewindRead(0);
144 MessageParcel reply;
145 DelayedSingleton<CoreService>::GetInstance()->OnSetShowName(dataMessageParcel, reply);
146 }
147
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)148 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
149 {
150 if (data == nullptr || size == 0) {
151 return;
152 }
153
154 GetShowName(data, size);
155 GetSimSpn(data, size);
156 GetSimIccId(data, size);
157 GetIMSI(data, size);
158 IsSimActive(data, size);
159 SetShowName(data, size);
160 }
161 } // namespace OHOS
162
163 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)164 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
165 {
166 OHOS::AddCoreServiceTokenFuzzer token;
167 /* Run your code on data */
168 OHOS::DoSomethingInterestingWithMyAPI(data, size);
169 return 0;
170 }
171