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 "softbusclientstub_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include "softbus_client_stub.h"
21 #include "message_parcel.h"
22 #include "securec.h"
23
24 namespace OHOS {
25 constexpr size_t FOO_MAX_LEN = 1024;
26 constexpr size_t U32_AT_SIZE = 4;
27
28 enum SoftBusFuncId {
29 CLIENT_ON_CHANNEL_OPENED = 256,
30 CLIENT_ON_CHANNEL_OPENFAILED,
31 CLIENT_ON_CHANNEL_LINKDOWN,
32 CLIENT_ON_CHANNEL_CLOSED,
33 CLIENT_ON_CHANNEL_MSGRECEIVED,
34 CLIENT_ON_CHANNEL_QOSEVENT,
35
36 CLIENT_DISCOVERY_SUCC,
37 CLIENT_DISCOVERY_FAIL,
38 CLIENT_DISCOVERY_DEVICE_FOUND,
39 CLIENT_PUBLISH_SUCC,
40 CLIENT_PUBLISH_FAIL,
41
42 CLIENT_ON_JOIN_RESULT,
43 CLIENT_ON_JOIN_METANODE_RESULT,
44 CLIENT_ON_LEAVE_RESULT,
45 CLIENT_ON_LEAVE_METANODE_RESULT,
46 CLIENT_ON_NODE_ONLINE_STATE_CHANGED,
47 CLIENT_ON_NODE_BASIC_INFO_CHANGED,
48 CLIENT_ON_TIME_SYNC_RESULT,
49 CLIENT_ON_PUBLISH_LNN_RESULT,
50 CLIENT_ON_REFRESH_LNN_RESULT,
51 CLIENT_ON_REFRESH_DEVICE_FOUND,
52 CLIENT_ON_PERMISSION_CHANGE,
53 };
54
55 const std::u16string SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN = u"OHOS.ISoftBusClient";
56
OnChannelOpenedInnerTest(const uint8_t * data,size_t size)57 bool OnChannelOpenedInnerTest(const uint8_t* data, size_t size)
58 {
59 const char* charStr = reinterpret_cast<const char*>(data);
60 constexpr int32_t intNum = 8;
61 constexpr size_t len = 4;
62 MessageParcel datas;
63 bool boolNum = true;
64 const char* test = "test";
65 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
66 datas.WriteCString(charStr);
67 datas.WriteInt32(intNum);
68 datas.WriteBool(boolNum);
69 datas.WriteRawData(test, len);
70 datas.RewindRead(0);
71 MessageParcel reply;
72 MessageOption option;
73 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
74 if (softBusClientStub == nullptr) {
75 return false;
76 }
77 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_OPENED, datas, reply, option);
78 return true;
79 }
80
OnChannelOpenFailedInnerTest(const uint8_t * data,size_t size)81 bool OnChannelOpenFailedInnerTest(const uint8_t* data, size_t size)
82 {
83 (void)size;
84 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
85 constexpr int32_t channelType = 4;
86 constexpr int32_t errCode = 5;
87 MessageParcel datas;
88 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
89 datas.WriteInt32(intNum);
90 datas.WriteInt32(channelType);
91 datas.WriteInt32(errCode);
92 datas.RewindRead(0);
93 MessageParcel reply;
94 MessageOption option;
95 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
96 if (softBusClientStub == nullptr) {
97 return false;
98 }
99 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_OPENFAILED, datas, reply, option);
100 return true;
101 }
102
OnChannelLinkDownInnerTest(const uint8_t * data,size_t size)103 bool OnChannelLinkDownInnerTest(const uint8_t* data, size_t size)
104 {
105 (void)size;
106 const char* charStr = reinterpret_cast<const char*>(data);
107 constexpr int32_t intNum = 4;
108 MessageParcel datas;
109 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
110 datas.WriteCString(charStr);
111 datas.WriteInt32(intNum);
112 datas.RewindRead(0);
113 MessageParcel reply;
114 MessageOption option;
115 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
116 if (softBusClientStub == nullptr) {
117 return false;
118 }
119 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_LINKDOWN, datas, reply, option);
120 return true;
121 }
122
OnChannelClosedInnerTest(const uint8_t * data,size_t size)123 bool OnChannelClosedInnerTest(const uint8_t* data, size_t size)
124 {
125 (void)size;
126 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
127 constexpr int32_t channelType = 4;
128 MessageParcel datas;
129 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
130 datas.WriteInt32(intNum);
131 datas.WriteInt32(channelType);
132 datas.RewindRead(0);
133 MessageParcel reply;
134 MessageOption option;
135 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
136 if (softBusClientStub == nullptr) {
137 return false;
138 }
139 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_CLOSED, datas, reply, option);
140 return true;
141 }
142
OnChannelMsgReceivedInnerTest(const uint8_t * data,size_t size)143 bool OnChannelMsgReceivedInnerTest(const uint8_t* data, size_t size)
144 {
145 (void)size;
146 constexpr int32_t channelId = 4;
147 constexpr int32_t channelType = 2;
148 constexpr uint32_t len = 18;
149 constexpr int32_t type = 2;
150 constexpr size_t lenStr = 4;
151 const char* test = "test";
152 const char* dataInfo = reinterpret_cast<const char*>(data);
153 MessageParcel datas;
154 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
155 datas.WriteInt32(channelId);
156 datas.WriteInt32(channelType);
157 datas.WriteUint32(len);
158 datas.WriteRawData(test, lenStr);
159 datas.WriteCString(dataInfo);
160 datas.WriteInt32(type);
161 datas.RewindRead(0);
162 MessageParcel reply;
163 MessageOption option;
164 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
165 if (softBusClientStub == nullptr) {
166 return false;
167 }
168 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_MSGRECEIVED, datas, reply, option);
169 return true;
170 }
171
OnChannelQosEventInnerTest(const uint8_t * data,size_t size)172 bool OnChannelQosEventInnerTest(const uint8_t* data, size_t size)
173 {
174 int32_t channelId = *(reinterpret_cast<const int32_t*>(data));
175 constexpr int32_t channelType = 3;
176 constexpr int32_t eventId = 2;
177 constexpr int32_t tvCount = 1;
178 constexpr size_t len = 4;
179 const char* test = "test";
180 MessageParcel datas;
181 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
182 datas.WriteInt32(channelId);
183 datas.WriteInt32(channelType);
184 datas.WriteInt32(eventId);
185 datas.WriteRawData(test, len);
186 datas.WriteInt32(tvCount);
187 datas.RewindRead(0);
188 MessageParcel reply;
189 MessageOption option;
190 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
191 if (softBusClientStub == nullptr) {
192 return false;
193 }
194 softBusClientStub->OnRemoteRequest(CLIENT_ON_CHANNEL_QOSEVENT, datas, reply, option);
195 return true;
196 }
197
OnDeviceFoundInnerTest(const uint8_t * data,size_t size)198 bool OnDeviceFoundInnerTest(const uint8_t* data, size_t size)
199 {
200 const char* charStr = reinterpret_cast<const char*>(data);
201 MessageParcel datas;
202 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
203 datas.WriteBuffer(charStr, size);
204 datas.RewindRead(0);
205 MessageParcel reply;
206 MessageOption option;
207 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
208 if (softBusClientStub == nullptr) {
209 return false;
210 }
211 softBusClientStub->OnRemoteRequest(CLIENT_DISCOVERY_DEVICE_FOUND, datas, reply, option);
212 return true;
213 }
214
OnJoinLNNResultInnerTest(const uint8_t * data,size_t size)215 bool OnJoinLNNResultInnerTest(const uint8_t* data, size_t size)
216 {
217 (void)size;
218 constexpr uint32_t addrTypeLen = 10;
219 constexpr int32_t retCode = 2;
220 const char* test = "test";
221 constexpr size_t len = 4;
222 const char* charStr = reinterpret_cast<const char*>(data);
223 MessageParcel datas;
224 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
225 datas.WriteUint32(addrTypeLen);
226 datas.WriteInt32(retCode);
227 datas.WriteRawData(test, len);
228 datas.WriteCString(charStr);
229 datas.RewindRead(0);
230 MessageParcel reply;
231 MessageOption option;
232 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
233 if (softBusClientStub == nullptr) {
234 return false;
235 }
236 softBusClientStub->OnRemoteRequest(CLIENT_ON_JOIN_RESULT, datas, reply, option);
237 return true;
238 }
239
OnJoinMetaNodeResultInnerTest(const uint8_t * data,size_t size)240 bool OnJoinMetaNodeResultInnerTest(const uint8_t* data, size_t size)
241 {
242 (void)size;
243 constexpr uint32_t addrTypeLen = 12;
244 constexpr int32_t retCode = 2;
245 const char* test = "test";
246 constexpr size_t len = 4;
247 const char* charStr = reinterpret_cast<const char*>(data);
248 MessageParcel datas;
249 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
250 datas.WriteUint32(addrTypeLen);
251 datas.WriteInt32(retCode);
252 datas.WriteRawData(test, len);
253 datas.WriteCString(charStr);
254 datas.RewindRead(0);
255 MessageParcel reply;
256 MessageOption option;
257 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
258 if (softBusClientStub == nullptr) {
259 return false;
260 }
261 softBusClientStub->OnRemoteRequest(CLIENT_ON_JOIN_METANODE_RESULT, datas, reply, option);
262 return true;
263 }
264
OnLeaveLNNResultInnerTest(const uint8_t * data,size_t size)265 bool OnLeaveLNNResultInnerTest(const uint8_t* data, size_t size)
266 {
267 (void)size;
268 const char* charStr = "package name test";
269 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
270 MessageParcel datas;
271 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
272 datas.WriteCString(charStr);
273 datas.WriteInt32(intNum);
274 datas.RewindRead(0);
275 MessageParcel reply;
276 MessageOption option;
277 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
278 if (softBusClientStub == nullptr) {
279 return false;
280 }
281 softBusClientStub->OnRemoteRequest(CLIENT_ON_LEAVE_RESULT, datas, reply, option);
282 return true;
283 }
284
OnLeaveMetaNodeResultInnerTest(const uint8_t * data,size_t size)285 bool OnLeaveMetaNodeResultInnerTest(const uint8_t* data, size_t size)
286 {
287 (void)size;
288 const char* charStr = "package name test";
289 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
290 MessageParcel datas;
291 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
292 datas.WriteCString(charStr);
293 datas.WriteInt32(intNum);
294 datas.RewindRead(0);
295 MessageParcel reply;
296 MessageOption option;
297 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
298 if (softBusClientStub == nullptr) {
299 return false;
300 }
301 softBusClientStub->OnRemoteRequest(CLIENT_ON_LEAVE_METANODE_RESULT, datas, reply, option);
302 return true;
303 }
304
OnNodeOnlineStateChangedInnerTest(const uint8_t * data,size_t size)305 bool OnNodeOnlineStateChangedInnerTest(const uint8_t* data, size_t size)
306 {
307 const char* charStr = reinterpret_cast<const char*>(data);
308 constexpr uint32_t infoTypeLen = 10;
309 bool boolNum = true;
310 const char* test = "test";
311 constexpr size_t len = 4;
312 MessageParcel datas;
313 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
314 datas.WriteCString(charStr);
315 datas.WriteBool(boolNum);
316 datas.WriteUint32(infoTypeLen);
317 datas.WriteRawData(test, len);
318 datas.RewindRead(0);
319 MessageParcel reply;
320 MessageOption option;
321 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
322 if (softBusClientStub == nullptr) {
323 return false;
324 }
325 softBusClientStub->OnRemoteRequest(CLIENT_ON_NODE_ONLINE_STATE_CHANGED, datas, reply, option);
326 return true;
327 }
328
OnNodeBasicInfoChangedInnerTest(const uint8_t * data,size_t size)329 bool OnNodeBasicInfoChangedInnerTest(const uint8_t* data, size_t size)
330 {
331 const char* charStr = reinterpret_cast<const char*>(data);
332 constexpr int32_t type = 2;
333 constexpr uint32_t infoTypeLen = 10;
334 const char* test = "test";
335 constexpr size_t len = 4;
336 MessageParcel datas;
337 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
338 datas.WriteCString(charStr);
339 datas.WriteRawData(test, len);
340 datas.WriteInt32(type);
341 datas.WriteUint32(infoTypeLen);
342 datas.RewindRead(0);
343 MessageParcel reply;
344 MessageOption option;
345 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
346 if (softBusClientStub == nullptr) {
347 return false;
348 }
349 softBusClientStub->OnRemoteRequest(CLIENT_ON_NODE_BASIC_INFO_CHANGED, datas, reply, option);
350 return true;
351 }
352
OnTimeSyncResultInnerTest(const uint8_t * data,size_t size)353 bool OnTimeSyncResultInnerTest(const uint8_t* data, size_t size)
354 {
355 constexpr uint32_t infoTypeLen = 10;
356 int32_t retCode = *(reinterpret_cast<const char*>(data));
357 const char* test = "test";
358 constexpr size_t len = 4;
359 MessageParcel datas;
360 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
361 datas.WriteInt32(retCode);
362 datas.WriteUint32(infoTypeLen);
363 datas.WriteRawData(test, len);
364 datas.RewindRead(0);
365 MessageParcel reply;
366 MessageOption option;
367 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
368 if (softBusClientStub == nullptr) {
369 return false;
370 }
371 softBusClientStub->OnRemoteRequest(CLIENT_ON_TIME_SYNC_RESULT, datas, reply, option);
372 return true;
373 }
374
OnPublishLNNResultInnerTest(const uint8_t * data,size_t size)375 bool OnPublishLNNResultInnerTest(const uint8_t* data, size_t size)
376 {
377 (void)size;
378 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
379 constexpr int32_t reason = 2;
380 MessageParcel datas;
381 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
382 datas.WriteInt32(intNum);
383 datas.WriteInt32(reason);
384 datas.RewindRead(0);
385 MessageParcel reply;
386 MessageOption option;
387 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
388 if (softBusClientStub == nullptr) {
389 return false;
390 }
391 softBusClientStub->OnRemoteRequest(CLIENT_ON_PUBLISH_LNN_RESULT, datas, reply, option);
392 return true;
393 }
394
OnRefreshLNNResultInnerTest(const uint8_t * data,size_t size)395 bool OnRefreshLNNResultInnerTest(const uint8_t* data, size_t size)
396 {
397 (void)size;
398 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
399 constexpr int32_t reason = 8;
400 MessageParcel datas;
401 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
402 datas.WriteInt32(intNum);
403 datas.WriteInt32(reason);
404 datas.RewindRead(0);
405 MessageParcel reply;
406 MessageOption option;
407 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
408 if (softBusClientStub == nullptr) {
409 return false;
410 }
411 softBusClientStub->OnRemoteRequest(CLIENT_ON_REFRESH_LNN_RESULT, datas, reply, option);
412 return true;
413 }
414
OnRefreshDeviceFoundInnerTest(const uint8_t * data,size_t size)415 bool OnRefreshDeviceFoundInnerTest(const uint8_t* data, size_t size)
416 {
417 uint32_t deviceLen = *(reinterpret_cast<const int32_t*>(data));
418 const char* test = "test";
419 MessageParcel datas;
420 constexpr size_t len = 4;
421 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
422 datas.WriteUint32(deviceLen);
423 datas.WriteRawData(test, len);
424 datas.RewindRead(0);
425 MessageParcel reply;
426 MessageOption option;
427 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
428 if (softBusClientStub == nullptr) {
429 return false;
430 }
431 softBusClientStub->OnRemoteRequest(CLIENT_ON_REFRESH_DEVICE_FOUND, datas, reply, option);
432 return true;
433 }
434
OnClientPermissonChangeInnerTest(const uint8_t * data,size_t size)435 bool OnClientPermissonChangeInnerTest(const uint8_t* data, size_t size)
436 {
437 (void)size;
438 const char* charStr = reinterpret_cast<const char*>(data);
439 int32_t intNum = *(reinterpret_cast<const int32_t*>(data));
440 MessageParcel datas;
441 datas.WriteInterfaceToken(SOFTBUS_CLIENT_STUB_INTERFACE_TOKEN);
442 datas.WriteCString(charStr);
443 datas.WriteInt32(intNum);
444 datas.RewindRead(0);
445 MessageParcel reply;
446 MessageOption option;
447 sptr<OHOS::SoftBusClientStub> softBusClientStub = new OHOS::SoftBusClientStub();
448 if (softBusClientStub == nullptr) {
449 return false;
450 }
451 softBusClientStub->OnRemoteRequest(CLIENT_ON_PERMISSION_CHANGE, datas, reply, option);
452 return true;
453 }
454 }
455
456 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)457 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
458 {
459 /* Run your code on data */
460 if (data == nullptr) {
461 return 0;
462 }
463
464 if (size < OHOS::U32_AT_SIZE) {
465 return 0;
466 }
467
468 /* Validate the length of size */
469 if (size == 0 || size > OHOS::FOO_MAX_LEN) {
470 return 0;
471 }
472 OHOS::OnChannelOpenedInnerTest(data, size);
473 OHOS::OnChannelOpenFailedInnerTest(data, size);
474 OHOS::OnChannelLinkDownInnerTest(data, size);
475 OHOS::OnChannelClosedInnerTest(data, size);
476 OHOS::OnChannelMsgReceivedInnerTest(data, size);
477 OHOS::OnChannelQosEventInnerTest(data, size);
478 OHOS::OnDeviceFoundInnerTest(data, size);
479 OHOS::OnJoinLNNResultInnerTest(data, size);
480 OHOS::OnJoinMetaNodeResultInnerTest(data, size);
481 OHOS::OnLeaveLNNResultInnerTest(data, size);
482 OHOS::OnLeaveMetaNodeResultInnerTest(data, size);
483 OHOS::OnNodeOnlineStateChangedInnerTest(data, size);
484 OHOS::OnNodeBasicInfoChangedInnerTest(data, size);
485 OHOS::OnTimeSyncResultInnerTest(data, size);
486 OHOS::OnPublishLNNResultInnerTest(data, size);
487 OHOS::OnRefreshLNNResultInnerTest(data, size);
488 OHOS::OnRefreshDeviceFoundInnerTest(data, size);
489 OHOS::OnClientPermissonChangeInnerTest(data, size);
490 return 0;
491 }
492