1 /*
2 * Copyright (c) 2022-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 <securec.h>
17 #include <thread>
18
19 #include "common_net_conn_callback_test.h"
20 #include "i_net_supplier_callback.h"
21 #include "iservice_registry.h"
22 #include "net_conn_constants.h"
23 #include "net_mgr_log_wrapper.h"
24 #include "netmanager_base_test_security.h"
25 #include "system_ability_definition.h"
26 #define private public
27 #include "net_conn_client.h"
28 #include "net_conn_service.h"
29 #include "net_conn_service_stub.h"
30 #include "net_interface_callback_stub.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 namespace {
35 const uint8_t *g_baseFuzzData = nullptr;
36 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
37 size_t g_baseFuzzSize = 0;
38 size_t g_baseFuzzPos;
39 constexpr size_t STR_LEN = 10;
40 } // namespace
41
GetData()42 template <class T> T GetData()
43 {
44 T object{};
45 size_t objectSize = sizeof(object);
46 if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
47 return object;
48 }
49 errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
50 if (ret != EOK) {
51 return {};
52 }
53 g_baseFuzzPos += objectSize;
54 return object;
55 }
56
GetStringFromData(int strlen)57 std::string GetStringFromData(int strlen)
58 {
59 char cstr[strlen];
60 cstr[strlen - 1] = '\0';
61 for (int i = 0; i < strlen - 1; i++) {
62 cstr[i] = GetData<char>();
63 }
64 std::string str(cstr);
65 return str;
66 }
67
68 class INetDetectionCallbackTest : public IRemoteStub<INetDetectionCallback> {
69 public:
OnNetDetectionResultChanged(NetDetectionResultCode detectionResult,const std::string & urlRedirect)70 virtual int32_t OnNetDetectionResultChanged(NetDetectionResultCode detectionResult, const std::string &urlRedirect)
71 {
72 return 0;
73 }
74 };
75
76 class NetInterfaceStateCallbackTest : public NetInterfaceStateCallbackStub {};
77
78 static bool g_isInited = false;
Init()79 void Init()
80 {
81 if (!g_isInited) {
82 if (!DelayedSingleton<NetConnService>::GetInstance()->Init()) {
83 g_isInited = false;
84 } else {
85 g_isInited = true;
86 }
87 }
88 }
89
OnRemoteRequest(uint32_t code,MessageParcel & data)90 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
91 {
92 if (!g_isInited) {
93 Init();
94 }
95
96 MessageParcel reply;
97 MessageOption option;
98
99 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
100 return ret;
101 }
102
WriteInterfaceToken(MessageParcel & data)103 bool WriteInterfaceToken(MessageParcel &data)
104 {
105 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
106 return false;
107 }
108 return true;
109 }
110
IsConnClientDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)111 bool IsConnClientDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
112 {
113 if ((data == nullptr) || (size == 0)) {
114 return false;
115 }
116 g_baseFuzzData = data;
117 g_baseFuzzSize = size;
118 g_baseFuzzPos = 0;
119
120 if (!WriteInterfaceToken(dataParcel)) {
121 return false;
122 }
123 return true;
124 }
125
SetAppHttpProxyCallback(const HttpProxy & httpProxy)126 void SetAppHttpProxyCallback(const HttpProxy &httpProxy)
127 {
128 return;
129 }
130
SystemReadyFuzzTest(const uint8_t * data,size_t size)131 void SystemReadyFuzzTest(const uint8_t *data, size_t size)
132 {
133 NetManagerBaseAccessToken token;
134
135 MessageParcel dataParcel;
136 if (!WriteInterfaceToken(dataParcel)) {
137 return;
138 }
139 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SYSTEM_READY), dataParcel);
140 }
141
RegisterNetSupplierFuzzTest(const uint8_t * data,size_t size)142 void RegisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
143 {
144 NetManagerBaseAccessToken token;
145 MessageParcel dataParcel;
146 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
147 return;
148 }
149 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
150 dataParcel.WriteUint32(bearerType);
151
152 std::string ident = GetStringFromData(STR_LEN);
153 dataParcel.WriteString(ident);
154
155 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
156 uint32_t capsSize = static_cast<uint32_t>(netCaps.size());
157 dataParcel.WriteUint32(capsSize);
158 for (auto netCap : netCaps) {
159 dataParcel.WriteUint32(static_cast<uint32_t>(netCap));
160 }
161
162 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REG_NET_SUPPLIER), dataParcel);
163 }
164
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)165 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
166 {
167 NetManagerBaseAccessToken token;
168 uint32_t supplierId = GetData<uint32_t>();
169 MessageParcel dataParcel;
170 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
171 return;
172 }
173 dataParcel.WriteUint32(supplierId);
174 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREG_NETWORK), dataParcel);
175 }
176
HasDefaultNetFuzzTest(const uint8_t * data,size_t size)177 void HasDefaultNetFuzzTest(const uint8_t *data, size_t size)
178 {
179 NetManagerBaseAccessToken token;
180
181 MessageParcel dataParcel;
182 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
183 return;
184 }
185
186 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_HASDEFAULTNET), dataParcel);
187 }
188
GetAllNetsFuzzTest(const uint8_t * data,size_t size)189 void GetAllNetsFuzzTest(const uint8_t *data, size_t size)
190 {
191 if ((data == nullptr) || (size == 0)) {
192 return;
193 }
194 NetManagerBaseAccessToken token;
195
196 MessageParcel dataParcel;
197 if (!WriteInterfaceToken(dataParcel)) {
198 return;
199 }
200
201 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ALL_NETS), dataParcel);
202 }
203
BindSocketFuzzTest(const uint8_t * data,size_t size)204 void BindSocketFuzzTest(const uint8_t *data, size_t size)
205 {
206 NetManagerBaseAccessToken token;
207 int32_t socketFd = GetData<int32_t>();
208 int32_t netId = GetData<int32_t>();
209 MessageParcel dataParcel;
210 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
211 return;
212 }
213 dataParcel.WriteInt32(socketFd);
214 dataParcel.WriteInt32(netId);
215 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_BIND_SOCKET), dataParcel);
216 }
217
SetAirplaneModeFuzzTest(const uint8_t * data,size_t size)218 void SetAirplaneModeFuzzTest(const uint8_t *data, size_t size)
219 {
220 NetManagerBaseAccessToken token;
221 bool state = GetData<bool>();
222
223 MessageParcel dataParcel;
224 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
225 return;
226 }
227 dataParcel.WriteBool(state);
228 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcel);
229 }
230
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)231 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
232 {
233 NetManagerBaseAccessToken token;
234 uint32_t supplierId = GetData<uint32_t>();
235 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
236
237 MessageParcel dataParcel;
238 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
239 return;
240 }
241 dataParcel.WriteUint32(supplierId);
242 netSupplierInfo->Marshalling(dataParcel);
243 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
244 }
245
GetAddressByNameFuzzTest(const uint8_t * data,size_t size)246 void GetAddressByNameFuzzTest(const uint8_t *data, size_t size)
247 {
248 NetManagerBaseAccessToken token;
249 std::string host = GetStringFromData(STR_LEN);
250 int32_t netId = GetData<int32_t>();
251
252 MessageParcel dataParcel;
253 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
254 return;
255 }
256 dataParcel.WriteString(host);
257 dataParcel.WriteInt32(netId);
258
259 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcel);
260 }
261
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)262 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
263 {
264 NetManagerBaseAccessToken token;
265 std::string host = GetStringFromData(STR_LEN);
266 int32_t netId = GetData<int32_t>();
267
268 MessageParcel dataParcel;
269 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
270 return;
271 }
272 dataParcel.WriteString(host);
273 dataParcel.WriteInt32(netId);
274
275 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcel);
276 }
277
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)278 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
279 {
280 uint32_t supplierId = GetData<uint32_t>();
281 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
282 if (netLinkInfo == nullptr) {
283 return;
284 }
285
286 MessageParcel dataParcel;
287 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
288 return;
289 }
290 dataParcel.WriteUint32(supplierId);
291 netLinkInfo->Marshalling(dataParcel);
292
293 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcel);
294 }
295
RegisterNetSupplierCallbackFuzzTest(const uint8_t * data,size_t size)296 void RegisterNetSupplierCallbackFuzzTest(const uint8_t *data, size_t size)
297 {
298 NetManagerBaseAccessToken token;
299 uint32_t supplierId = GetData<uint32_t>();
300 sptr<NetSupplierCallbackStubTestCb> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
301 if (callback == nullptr) {
302 return;
303 }
304
305 MessageParcel dataParcel;
306 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
307 return;
308 }
309 dataParcel.WriteUint32(supplierId);
310 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
311
312 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK), dataParcel);
313 }
314
RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t * data,size_t size)315 void RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t *data, size_t size)
316 {
317 NetManagerBaseAccessToken token;
318 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
319 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
320 if (netSpecifier == nullptr || callback == nullptr) {
321 return;
322 }
323 uint32_t timeoutMS = GetData<uint32_t>();
324
325 MessageParcel dataParcel;
326 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
327 return;
328 }
329 netSpecifier->Marshalling(dataParcel);
330 dataParcel.WriteUint32(timeoutMS);
331 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
332
333 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
334 dataParcel);
335 }
336
RegisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)337 void RegisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
338 {
339 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
340 if (callback == nullptr) {
341 return;
342 }
343
344 MessageParcel dataParcel;
345 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
346 return;
347 }
348
349 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
350
351 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK), dataParcel);
352 }
353
UnregisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)354 void UnregisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
355 {
356 if ((data == nullptr) || (size == 0)) {
357 return;
358 }
359
360 NetManagerBaseAccessToken token;
361 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
362 if (callback == nullptr) {
363 return;
364 }
365
366 MessageParcel dataParcel;
367 if (!WriteInterfaceToken(dataParcel)) {
368 return;
369 }
370 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
371
372 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK), dataParcel);
373 }
374
GetDefaultNetFuzzTest(const uint8_t * data,size_t size)375 void GetDefaultNetFuzzTest(const uint8_t *data, size_t size)
376 {
377 NetManagerBaseAccessToken token;
378
379 MessageParcel dataParcel;
380 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
381 return;
382 }
383 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GETDEFAULTNETWORK), dataParcel);
384 }
385
GetConnectionPropertiesFuzzTest(const uint8_t * data,size_t size)386 void GetConnectionPropertiesFuzzTest(const uint8_t *data, size_t size)
387 {
388 NetManagerBaseAccessToken token;
389 int32_t netId = GetData<int32_t>();
390
391 MessageParcel dataParcel;
392 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
393 return;
394 }
395 dataParcel.WriteInt32(netId);
396 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcel);
397 }
398
GetNetCapabilitiesFuzzTest(const uint8_t * data,size_t size)399 void GetNetCapabilitiesFuzzTest(const uint8_t *data, size_t size)
400 {
401 NetManagerBaseAccessToken token;
402 int32_t netId = GetData<int32_t>();
403
404 MessageParcel dataParcel;
405 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
406 return;
407 }
408 dataParcel.WriteInt32(netId);
409 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcel);
410 }
411
NetDetectionFuzzTest(const uint8_t * data,size_t size)412 void NetDetectionFuzzTest(const uint8_t *data, size_t size)
413 {
414 NetManagerBaseAccessToken tokenInternetInfo;
415 int32_t netId = GetData<int32_t>();
416
417 MessageParcel dataParcel;
418 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
419 return;
420 }
421 dataParcel.WriteInt32(netId);
422 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcel);
423 }
424
IsDefaultNetMeteredFuzzTest(const uint8_t * data,size_t size)425 void IsDefaultNetMeteredFuzzTest(const uint8_t *data, size_t size)
426 {
427 NetManagerBaseAccessToken token;
428
429 MessageParcel dataParcel;
430 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
431 return;
432 }
433 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_DEFAULT_NET_METERED), dataParcel);
434 }
435
436
SetAppHttpProxyFuzzTest(const uint8_t * data,size_t size)437 void SetAppHttpProxyFuzzTest(const uint8_t *data, size_t size)
438 {
439 HttpProxy httpProxy = {GetStringFromData(STR_LEN), 0, {}};
440 DelayedSingleton<NetConnClient>::GetInstance()->SetAppHttpProxy(httpProxy);
441 }
442
RegisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)443 void RegisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
444 {
445 uint32_t callbackId = 0;
446 DelayedSingleton<NetConnClient>::GetInstance()->RegisterAppHttpProxyCallback(SetAppHttpProxyCallback, callbackId);
447 }
448
UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)449 void UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
450 {
451 int32_t callbackId = GetData<int32_t>();
452 DelayedSingleton<NetConnClient>::GetInstance()->UnregisterAppHttpProxyCallback(callbackId);
453 }
454
SetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)455 void SetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
456 {
457 NetManagerBaseAccessToken token;
458 HttpProxy httpProxy = {GetStringFromData(STR_LEN), 0, {}};
459
460 MessageParcel dataParcel;
461 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
462 return;
463 }
464 httpProxy.Marshalling(dataParcel);
465 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_GLOBAL_HTTP_PROXY), dataParcel);
466 }
467
GetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)468 void GetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
469 {
470 NetManagerBaseAccessToken token;
471
472 MessageParcel dataParcel;
473 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
474 return;
475 }
476 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_GLOBAL_HTTP_PROXY), dataParcel);
477 }
478
GetDefaultHttpProxyFuzzTest(const uint8_t * data,size_t size)479 void GetDefaultHttpProxyFuzzTest(const uint8_t *data, size_t size)
480 {
481 NetManagerBaseAccessToken token;
482
483 MessageParcel dataParcel;
484 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
485 return;
486 }
487 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_DEFAULT_HTTP_PROXY), dataParcel);
488 }
489
GetNetIdByIdentifierFuzzTest(const uint8_t * data,size_t size)490 void GetNetIdByIdentifierFuzzTest(const uint8_t *data, size_t size)
491 {
492 NetManagerBaseAccessToken token;
493 std::string ident = GetStringFromData(STR_LEN);
494
495 MessageParcel dataParcel;
496 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
497 return;
498 }
499 dataParcel.WriteString(ident);
500 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcel);
501 }
502
RegisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)503 void RegisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
504 {
505 if ((data == nullptr) || (size == 0)) {
506 return;
507 }
508
509 NetManagerBaseAccessToken token;
510 sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
511 if (callback == nullptr) {
512 return;
513 }
514
515 MessageParcel dataParcel;
516 if (!WriteInterfaceToken(dataParcel)) {
517 return;
518 }
519 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
520 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK), dataParcel);
521 }
522
GetNetInterfaceConfigurationFuzzTest(const uint8_t * data,size_t size)523 void GetNetInterfaceConfigurationFuzzTest(const uint8_t *data, size_t size)
524 {
525 NetManagerBaseAccessToken token;
526
527 MessageParcel dataParcel;
528 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
529 return;
530 }
531 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcel);
532 }
533
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)534 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
535 {
536 uint32_t uid = GetData<uint32_t>();
537 uint8_t allow = GetData<uint8_t>();
538
539 NetManagerBaseAccessToken token;
540 MessageParcel dataParcel;
541 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
542 return;
543 }
544
545 dataParcel.WriteUint32(uid);
546 dataParcel.WriteUint8(allow);
547 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcel);
548 }
549
UpdateNetStateForTestFuzzTest(const uint8_t * data,size_t size)550 void UpdateNetStateForTestFuzzTest(const uint8_t *data, size_t size)
551 {
552 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
553 if (netSpecifier == nullptr) {
554 return;
555 }
556 auto netState = GetData<int32_t>();
557
558 MessageParcel dataParcel;
559 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
560 return;
561 }
562
563 netSpecifier->Marshalling(dataParcel);
564 dataParcel.WriteInt32(netState);
565 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcel);
566 }
567
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)568 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
569 {
570 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
571
572 MessageParcel dataParcel;
573 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
574 return;
575 }
576
577 dataParcel.WriteUint32(bearerType);
578
579 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcel);
580 }
581
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)582 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
583 {
584 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
585 std::string ident = GetStringFromData(STR_LEN);
586
587 MessageParcel dataParcel;
588 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
589 return;
590 }
591
592 dataParcel.WriteUint32(bearerType);
593 dataParcel.WriteString(ident);
594
595 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcel);
596 }
597
RegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)598 void RegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
599 {
600 int32_t netId = GetData<int32_t>();
601 sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
602 if (callback == nullptr) {
603 return;
604 }
605
606 MessageParcel dataParcel;
607 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
608 return;
609 }
610
611 dataParcel.WriteInt32(netId);
612 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
613
614 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
615 dataParcel);
616 }
617
UnRegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)618 void UnRegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
619 {
620 int32_t netId = GetData<int32_t>();
621 sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
622 if (callback == nullptr) {
623 return;
624 }
625
626 MessageParcel dataParcel;
627 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
628 return;
629 }
630
631 dataParcel.WriteInt32(netId);
632 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
633
634 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
635 dataParcel);
636 }
637
GetSpecificNetFuzzTest(const uint8_t * data,size_t size)638 void GetSpecificNetFuzzTest(const uint8_t *data, size_t size)
639 {
640 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
641
642 MessageParcel dataParcel;
643 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
644 return;
645 }
646
647 dataParcel.WriteUint32(bearerType);
648
649 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcel);
650 }
651
OnSetAppNetFuzzTest(const uint8_t * data,size_t size)652 void OnSetAppNetFuzzTest(const uint8_t *data, size_t size)
653 {
654 int32_t netId = GetData<int32_t>();
655
656 MessageParcel dataParcel;
657 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
658 return;
659 }
660
661 dataParcel.WriteInt32(netId);
662
663 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcel);
664 }
665
GetSpecificUidNetFuzzTest(const uint8_t * data,size_t size)666 void GetSpecificUidNetFuzzTest(const uint8_t *data, size_t size)
667 {
668 int32_t uid = GetData<int32_t>();
669 int32_t netId = GetData<int32_t>();
670
671 MessageParcel dataParcel;
672 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
673 return;
674 }
675
676 dataParcel.WriteInt32(uid);
677 dataParcel.WriteInt32(netId);
678
679 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcel);
680 }
681
AddNetworkRouteFuzzTest(const uint8_t * data,size_t size)682 void AddNetworkRouteFuzzTest(const uint8_t *data, size_t size)
683 {
684 MessageParcel dataParcel;
685 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
686 return;
687 }
688
689 int32_t netId = GetData<int32_t>();
690 std::string ifName = GetStringFromData(STR_LEN);
691 std::string destination = GetStringFromData(STR_LEN);
692 std::string nextHop = GetStringFromData(STR_LEN);
693 dataParcel.WriteInt32(netId);
694 dataParcel.WriteString(ifName);
695 dataParcel.WriteString(destination);
696 dataParcel.WriteString(nextHop);
697
698 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcel);
699 }
700
RemoveNetworkRouteFuzzTest(const uint8_t * data,size_t size)701 void RemoveNetworkRouteFuzzTest(const uint8_t *data, size_t size)
702 {
703 MessageParcel dataParcel;
704 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
705 return;
706 }
707
708 int32_t netId = GetData<int32_t>();
709 std::string ifName = GetStringFromData(STR_LEN);
710 std::string destination = GetStringFromData(STR_LEN);
711 std::string nextHop = GetStringFromData(STR_LEN);
712 dataParcel.WriteInt32(netId);
713 dataParcel.WriteString(ifName);
714 dataParcel.WriteString(destination);
715 dataParcel.WriteString(nextHop);
716
717 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcel);
718 }
719
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)720 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
721 {
722 MessageParcel dataParcel;
723 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
724 return;
725 }
726
727 int32_t prefixLength = GetData<int32_t>();
728 std::string ifName = GetStringFromData(STR_LEN);
729 std::string ipAddr = GetStringFromData(STR_LEN);
730 dataParcel.WriteString(ifName);
731 dataParcel.WriteString(ipAddr);
732 dataParcel.WriteInt32(prefixLength);
733
734 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcel);
735 }
736
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)737 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
738 {
739 MessageParcel dataParcel;
740 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
741 return;
742 }
743
744 int32_t prefixLength = GetData<int32_t>();
745 std::string ifName = GetStringFromData(STR_LEN);
746 std::string ipAddr = GetStringFromData(STR_LEN);
747 dataParcel.WriteString(ifName);
748 dataParcel.WriteString(ipAddr);
749 dataParcel.WriteInt32(prefixLength);
750
751 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcel);
752 }
753
StaticArpProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel)754 void StaticArpProcess(const uint8_t *data, size_t size, MessageParcel &dataParcel)
755 {
756 if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
757 return;
758 }
759
760 std::string ipAddr = GetStringFromData(STR_LEN);
761 std::string macAddr = GetStringFromData(STR_LEN);
762 std::string ifName = GetStringFromData(STR_LEN);
763 dataParcel.WriteString(ipAddr);
764 dataParcel.WriteString(macAddr);
765 dataParcel.WriteString(ifName);
766 }
767
AddStaticArpFuzzTest(const uint8_t * data,size_t size)768 void AddStaticArpFuzzTest(const uint8_t *data, size_t size)
769 {
770 MessageParcel dataParcel;
771 StaticArpProcess(data, size, dataParcel);
772 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcel);
773 }
774
DelStaticArpFuzzTest(const uint8_t * data,size_t size)775 void DelStaticArpFuzzTest(const uint8_t *data, size_t size)
776 {
777 MessageParcel dataParcel;
778 StaticArpProcess(data, size, dataParcel);
779 OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcel);
780 }
781 } // namespace NetManagerStandard
782 } // namespace OHOS
783
784 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)785 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
786 {
787 /* Run your code on data */
788 OHOS::NetManagerStandard::SystemReadyFuzzTest(data, size);
789 OHOS::NetManagerStandard::RegisterNetSupplierFuzzTest(data, size);
790 OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
791 OHOS::NetManagerStandard::RegisterNetSupplierCallbackFuzzTest(data, size);
792 OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
793 OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
794 OHOS::NetManagerStandard::RegisterNetConnCallbackBySpecifierFuzzTest(data, size);
795 OHOS::NetManagerStandard::RegisterNetConnCallbackFuzzTest(data, size);
796 OHOS::NetManagerStandard::UnregisterNetConnCallbackFuzzTest(data, size);
797 OHOS::NetManagerStandard::GetDefaultNetFuzzTest(data, size);
798 OHOS::NetManagerStandard::HasDefaultNetFuzzTest(data, size);
799 OHOS::NetManagerStandard::GetAllNetsFuzzTest(data, size);
800 OHOS::NetManagerStandard::GetConnectionPropertiesFuzzTest(data, size);
801 OHOS::NetManagerStandard::GetNetCapabilitiesFuzzTest(data, size);
802 OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
803 OHOS::NetManagerStandard::GetAddressByNameFuzzTest(data, size);
804 OHOS::NetManagerStandard::BindSocketFuzzTest(data, size);
805 OHOS::NetManagerStandard::NetDetectionFuzzTest(data, size);
806 OHOS::NetManagerStandard::SetAirplaneModeFuzzTest(data, size);
807 OHOS::NetManagerStandard::IsDefaultNetMeteredFuzzTest(data, size);
808 OHOS::NetManagerStandard::SetGlobalHttpProxyFuzzTest(data, size);
809 OHOS::NetManagerStandard::GetGlobalHttpProxyFuzzTest(data, size);
810 OHOS::NetManagerStandard::GetDefaultHttpProxyFuzzTest(data, size);
811 OHOS::NetManagerStandard::SetAppHttpProxyFuzzTest(data, size);
812 OHOS::NetManagerStandard::RegisterAppHttpProxyCallbackFuzzTest(data, size);
813 OHOS::NetManagerStandard::UnregisterAppHttpProxyCallbackFuzzTest(data, size);
814 OHOS::NetManagerStandard::GetNetIdByIdentifierFuzzTest(data, size);
815 OHOS::NetManagerStandard::RegisterNetInterfaceCallbackFuzzTest(data, size);
816 OHOS::NetManagerStandard::GetNetInterfaceConfigurationFuzzTest(data, size);
817 OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
818 OHOS::NetManagerStandard::UpdateNetStateForTestFuzzTest(data, size);
819 OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
820 OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
821 OHOS::NetManagerStandard::RegisterNetDetectionCallbackFuzzTest(data, size);
822 OHOS::NetManagerStandard::UnRegisterNetDetectionCallbackFuzzTest(data, size);
823 OHOS::NetManagerStandard::GetSpecificNetFuzzTest(data, size);
824 OHOS::NetManagerStandard::GetSpecificUidNetFuzzTest(data, size);
825 OHOS::NetManagerStandard::OnSetAppNetFuzzTest(data, size);
826 OHOS::NetManagerStandard::AddNetworkRouteFuzzTest(data, size);
827 OHOS::NetManagerStandard::RemoveNetworkRouteFuzzTest(data, size);
828 OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
829 OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
830 OHOS::NetManagerStandard::AddStaticArpFuzzTest(data, size);
831 OHOS::NetManagerStandard::DelStaticArpFuzzTest(data, size);
832 return 0;
833 }
834