1 /*
2 * Copyright (c) 2023 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 "sinkstubdaudiosinkstub_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <random>
21 #include <fuzzer/FuzzedDataProvider.h>
22
23 #include "daudio_sink_ipc_callback_proxy.h"
24 #include "daudio_sink_stub.h"
25 #include "daudio_sink_service.h"
26
27 #include "daudio_ipc_interface_code.h"
28 #include "if_system_ability_manager.h"
29 #include "iservice_registry.h"
30
ConsumeRandomString(FuzzedDataProvider & fdp,size_t maxLength)31 inline std::string ConsumeRandomString(FuzzedDataProvider& fdp, size_t maxLength)
32 {
33 return fdp.ConsumeRandomLengthString(maxLength);
34 }
35 namespace OHOS {
36 namespace DistributedHardware {
SinkStubDaudioSinkStubFuzzTest(const uint8_t * data,size_t size)37 void SinkStubDaudioSinkStubFuzzTest(const uint8_t* data, size_t size)
38 {
39 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
40 return;
41 }
42 FuzzedDataProvider fdp(data, size);
43 int32_t saId = fdp.ConsumeIntegral<int32_t>();
44 bool runOnCreate = fdp.ConsumeBool();
45 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
46 std::random_device rd;
47 MessageParcel pdata;
48 MessageParcel reply;
49 MessageOption option;
50 std::string devId = "1";
51 std::string dhId = "2";
52 std::string reqId = "3";
53 int32_t status = fdp.ConsumeIntegral<int32_t>();
54 std::string resultData = fdp.ConsumeRandomLengthString();
55 pdata.WriteString(devId);
56 pdata.WriteString(dhId);
57 pdata.WriteString(reqId);
58 pdata.WriteInt32(status);
59 pdata.WriteString(resultData);
60 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::INIT_SINK)] =
61 &DAudioSinkStub::InitSinkInner;
62 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RELEASE_SINK)] =
63 &DAudioSinkStub::ReleaseSinkInner;
64 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE)] =
65 &DAudioSinkStub::SubscribeLocalHardwareInner;
66 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE)] =
67 &DAudioSinkStub::UnsubscribeLocalHardwareInner;
68 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY)] =
69 &DAudioSinkStub::DAudioNotifyInner;
70 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] =
71 &DAudioSinkStub::PauseDistributedHardwareInner;
72 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] =
73 &DAudioSinkStub::ResumeDistributedHardwareInner;
74 dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE)] =
75 &DAudioSinkStub::StopDistributedHardwareInner;
76 const uint32_t code = fdp.ConsumeIntegral<const uint32_t>();
77 dAudioSinkService->OnRemoteRequest(code, pdata, reply, option);
78 }
79
SinkStubSubscribeLocalHardwareInnerFuzzTest(const uint8_t * data,size_t size)80 void SinkStubSubscribeLocalHardwareInnerFuzzTest(const uint8_t* data, size_t size)
81 {
82 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
83 return;
84 }
85 FuzzedDataProvider fdp(data, size);
86 int32_t saId = fdp.ConsumeIntegral<int32_t>();
87 bool runOnCreate = fdp.ConsumeBool();
88 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
89 std::random_device rd;
90 MessageParcel pdata;
91 MessageParcel reply;
92 MessageOption option;
93 std::string devId = "1";
94 std::string dhId = "2";
95 std::string reqId = "3";
96 int32_t status = fdp.ConsumeIntegral<int32_t>();
97 std::string resultData = fdp.ConsumeRandomLengthString();
98 pdata.WriteString(devId);
99 pdata.WriteString(dhId);
100 pdata.WriteString(reqId);
101 pdata.WriteInt32(status);
102 pdata.WriteString(resultData);
103 dAudioSinkService->SubscribeLocalHardwareInner(pdata, reply, option);
104 }
105
SinkStubUnsubscribeLocalHardwareInnerFuzzTest(const uint8_t * data,size_t size)106 void SinkStubUnsubscribeLocalHardwareInnerFuzzTest(const uint8_t* data, size_t size)
107 {
108 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
109 return;
110 }
111 FuzzedDataProvider fdp(data, size);
112 int32_t saId = fdp.ConsumeIntegral<int32_t>();
113 bool runOnCreate = fdp.ConsumeBool();
114 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
115 std::random_device rd;
116 MessageParcel pdata;
117 MessageParcel reply;
118 MessageOption option;
119 std::string devId = "1";
120 std::string dhId = "2";
121 std::string reqId = "3";
122 int32_t status = fdp.ConsumeIntegral<int32_t>();
123 std::string resultData = fdp.ConsumeRandomLengthString();
124 pdata.WriteString(devId);
125 pdata.WriteString(dhId);
126 pdata.WriteString(reqId);
127 pdata.WriteInt32(status);
128 pdata.WriteString(resultData);
129 dAudioSinkService->UnsubscribeLocalHardwareInner(pdata, reply, option);
130 }
131
SinkStubDAudioNotifyInnerFuzzTest(const uint8_t * data,size_t size)132 void SinkStubDAudioNotifyInnerFuzzTest(const uint8_t* data, size_t size)
133 {
134 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
135 return;
136 }
137 FuzzedDataProvider fdp(data, size);
138 int32_t saId = fdp.ConsumeIntegral<int32_t>();
139 bool runOnCreate = fdp.ConsumeBool();
140 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
141 std::random_device rd;
142 MessageParcel pdata;
143 MessageParcel reply;
144 MessageOption option;
145 std::string devId = "1";
146 std::string dhId = "2";
147 std::string reqId = "3";
148 int32_t status = fdp.ConsumeIntegral<int32_t>();
149 std::string resultData = fdp.ConsumeRandomLengthString();
150 pdata.WriteString(devId);
151 pdata.WriteString(dhId);
152 pdata.WriteString(reqId);
153 pdata.WriteInt32(status);
154 pdata.WriteString(resultData);
155 dAudioSinkService->DAudioNotifyInner(pdata, reply, option);
156 }
157
SinkStubPauseDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)158 void SinkStubPauseDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
159 {
160 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
161 return;
162 }
163 FuzzedDataProvider fdp(data, size);
164 int32_t saId = fdp.ConsumeIntegral<int32_t>();
165 bool runOnCreate = fdp.ConsumeBool();
166 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
167 std::random_device rd;
168 MessageParcel pdata;
169 MessageParcel reply;
170 MessageOption option;
171 std::string devId = "1";
172 std::string dhId = "2";
173 std::string reqId = "3";
174 int32_t status = fdp.ConsumeIntegral<int32_t>();
175 std::string resultData = fdp.ConsumeRandomLengthString();
176 pdata.WriteString(devId);
177 pdata.WriteString(dhId);
178 pdata.WriteString(reqId);
179 pdata.WriteInt32(status);
180 pdata.WriteString(resultData);
181 dAudioSinkService->PauseDistributedHardwareInner(pdata, reply, option);
182 }
183
SinkStubResumeDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)184 void SinkStubResumeDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
185 {
186 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
187 return;
188 }
189 FuzzedDataProvider fdp(data, size);
190 int32_t saId = fdp.ConsumeIntegral<int32_t>();
191 bool runOnCreate = fdp.ConsumeBool();
192 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
193 std::random_device rd;
194 MessageParcel pdata;
195 MessageParcel reply;
196 MessageOption option;
197 std::string devId = "1";
198 std::string dhId = "2";
199 std::string reqId = "3";
200 int32_t status = fdp.ConsumeIntegral<int32_t>();
201 std::string resultData = fdp.ConsumeRandomLengthString();
202 pdata.WriteString(devId);
203 pdata.WriteString(dhId);
204 pdata.WriteString(reqId);
205 pdata.WriteInt32(status);
206 pdata.WriteString(resultData);
207 dAudioSinkService->ResumeDistributedHardwareInner(pdata, reply, option);
208 }
209
SinkStubStopDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)210 void SinkStubStopDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
211 {
212 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
213 return;
214 }
215 FuzzedDataProvider fdp(data, size);
216 int32_t saId = fdp.ConsumeIntegral<int32_t>();
217 bool runOnCreate = fdp.ConsumeBool();
218 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
219 std::random_device rd;
220 MessageParcel pdata;
221 MessageParcel reply;
222 MessageOption option;
223 std::string devId = "1";
224 std::string dhId = "2";
225 std::string reqId = "3";
226 int32_t status = fdp.ConsumeIntegral<int32_t>();
227 std::string resultData = fdp.ConsumeRandomLengthString();
228 pdata.WriteString(devId);
229 pdata.WriteString(dhId);
230 pdata.WriteString(reqId);
231 pdata.WriteInt32(status);
232 pdata.WriteString(resultData);
233 dAudioSinkService->StopDistributedHardwareInner(pdata, reply, option);
234 }
235
SinkStubInitSinkInnerFuzzTest(const uint8_t * data,size_t size)236 void SinkStubInitSinkInnerFuzzTest(const uint8_t* data, size_t size)
237 {
238 if ((data == nullptr) || (size < (sizeof(int32_t)))) {
239 return;
240 }
241 FuzzedDataProvider fdp(data, size);
242
243 int32_t saId = fdp.ConsumeIntegral<int32_t>();
244 bool runOnCreate = fdp.ConsumeBool();
245 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
246
247 MessageParcel pdata;
248 MessageParcel reply;
249 MessageOption option;
250
251 std::string param = fdp.ConsumeRandomLengthString(100);
252 sptr<IRemoteObject> remoteObject = nullptr;
253 pdata.WriteString(param);
254 pdata.WriteRemoteObject(remoteObject);
255 dAudioSinkService->InitSinkInner(pdata, reply, option);
256 }
257
SinkStubReleaseSinkInnerFuzzTest(const uint8_t * data,size_t size)258 void SinkStubReleaseSinkInnerFuzzTest(const uint8_t* data, size_t size)
259 {
260 if (data == nullptr || size == 0) {
261 return;
262 }
263 FuzzedDataProvider fdp(data, size);
264
265 int32_t saId = fdp.ConsumeIntegral<int32_t>();
266 bool runOnCreate = fdp.ConsumeBool();
267 auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
268
269 MessageParcel pdata;
270 MessageParcel reply;
271 MessageOption option;
272
273 std::string dummyData = ConsumeRandomString(fdp, 100);
274 pdata.WriteString(dummyData);
275
276 dAudioSinkService->ReleaseSinkInner(pdata, reply, option);
277 }
278 }
279 }
280
281 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)282 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
283 {
284 /* Run your code on data */
285 OHOS::DistributedHardware::SinkStubDaudioSinkStubFuzzTest(data, size);
286 OHOS::DistributedHardware::SinkStubSubscribeLocalHardwareInnerFuzzTest(data, size);
287 OHOS::DistributedHardware::SinkStubUnsubscribeLocalHardwareInnerFuzzTest(data, size);
288 OHOS::DistributedHardware::SinkStubDAudioNotifyInnerFuzzTest(data, size);
289 OHOS::DistributedHardware::SinkStubPauseDistributedHardwareInnerFuzzTest(data, size);
290 OHOS::DistributedHardware::SinkStubResumeDistributedHardwareInnerFuzzTest(data, size);
291 OHOS::DistributedHardware::SinkStubStopDistributedHardwareInnerFuzzTest(data, size);
292 OHOS::DistributedHardware::SinkStubInitSinkInnerFuzzTest(data, size);
293 OHOS::DistributedHardware::SinkStubReleaseSinkInnerFuzzTest(data, size);
294 return 0;
295 }
296