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 <thread>
17
18 #include <securec.h>
19
20 #include "accesstoken_kit.h"
21 #include "iservice_registry.h"
22 #include "nativetoken_kit.h"
23 #include "system_ability_definition.h"
24 #include "token_setproc.h"
25
26 #include "i_net_supplier_callback.h"
27 #include "net_conn_constants.h"
28 #include "net_mgr_log_wrapper.h"
29 #include "net_supplier_callback_stub.h"
30 #define private public
31 #include "net_conn_service.h"
32 #include "net_conn_service_stub.h"
33
34 namespace OHOS {
35 namespace NetManagerStandard {
36 namespace {
37 const uint8_t *g_baseFuzzData = nullptr;
38 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
39 size_t g_baseFuzzSize = 0;
40 size_t g_baseFuzzPos;
41 constexpr size_t STR_LEN = 10;
42
43 using namespace Security::AccessToken;
44 using Security::AccessToken::AccessTokenID;
45 HapInfoParams testInfoParms = {.userID = 1,
46 .bundleName = "net_conn_client_fuzzer",
47 .instIndex = 0,
48 .appIDDesc = "test"};
49
50 PermissionDef testPermDef = {
51 .permissionName = "ohos.permission.GET_NETWORK_INFO",
52 .bundleName = "net_conn_client_fuzzer",
53 .grantMode = 1,
54 .availableLevel = APL_SYSTEM_BASIC,
55 .label = "label",
56 .labelId = 1,
57 .description = "Test net connect maneger network info",
58 .descriptionId = 1,
59 };
60
61 PermissionDef testInternetPermDef = {.permissionName = "ohos.permission.INTERNET",
62 .bundleName = "net_conn_client_fuzzer",
63 .grantMode = 1,
64 .availableLevel = APL_SYSTEM_BASIC,
65 .label = "label",
66 .labelId = 1,
67 .description = "Test net connect maneger internet",
68 .descriptionId = 1};
69
70 PermissionStateFull testState = {.permissionName = "ohos.permission.GET_NETWORK_INFO",
71 .isGeneral = true,
72 .resDeviceID = {"local"},
73 .grantStatus = {PermissionState::PERMISSION_GRANTED},
74 .grantFlags = {2}};
75
76 PermissionStateFull testInternetState = {.permissionName = "ohos.permission.INTERNET",
77 .isGeneral = true,
78 .resDeviceID = {"local"},
79 .grantStatus = {PermissionState::PERMISSION_GRANTED},
80 .grantFlags = {2}};
81
82 HapPolicyParams testPolicyPrams = {.apl = APL_SYSTEM_BASIC,
83 .domain = "test.domain",
84 .permList = {testPermDef},
85 .permStateList = {testState}};
86
87 HapPolicyParams testInternetPolicyPrams = {.apl = APL_SYSTEM_BASIC,
88 .domain = "test.domain",
89 .permList = {testPermDef, testInternetPermDef},
90 .permStateList = {testState, testInternetState}};
91 } // namespace
92
GetData()93 template <class T> T GetData()
94 {
95 T object{};
96 size_t objectSize = sizeof(object);
97 if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
98 return object;
99 }
100 errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
101 if (ret != EOK) {
102 return {};
103 }
104 g_baseFuzzPos += objectSize;
105 return object;
106 }
107
GetStringFromData(int strlen)108 std::string GetStringFromData(int strlen)
109 {
110 char cstr[strlen];
111 cstr[strlen - 1] = '\0';
112 for (int i = 0; i < strlen - 1; i++) {
113 cstr[i] = GetData<char>();
114 }
115 std::string str(cstr);
116 return str;
117 }
118
119 class AccessToken {
120 public:
AccessToken()121 AccessToken() : currentID_(GetSelfTokenID())
122 {
123 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testPolicyPrams);
124 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
125 SetSelfTokenID(accessID_);
126 }
~AccessToken()127 ~AccessToken()
128 {
129 AccessTokenKit::DeleteToken(accessID_);
130 SetSelfTokenID(currentID_);
131 }
132
133 private:
134 AccessTokenID currentID_;
135 AccessTokenID accessID_ = 0;
136 };
137
138 class AccessTokenInternetInfo {
139 public:
AccessTokenInternetInfo()140 AccessTokenInternetInfo()
141 {
142 currentID_ = GetSelfTokenID();
143 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(testInfoParms, testInternetPolicyPrams);
144 accessID_ = tokenIdEx.tokenIdExStruct.tokenID;
145 SetSelfTokenID(accessID_);
146 }
~AccessTokenInternetInfo()147 ~AccessTokenInternetInfo()
148 {
149 AccessTokenKit::DeleteToken(accessID_);
150 SetSelfTokenID(currentID_);
151 }
152
153 private:
154 AccessTokenID currentID_ = 0;
155 AccessTokenID accessID_ = 0;
156 };
157
158 class INetConnCallbackTest : public IRemoteStub<INetConnCallback> {
159 public:
NetAvailable(sptr<NetHandle> & netHandle)160 int32_t NetAvailable(sptr<NetHandle> &netHandle)
161 {
162 return 0;
163 }
164
NetCapabilitiesChange(sptr<NetHandle> & netHandle,const sptr<NetAllCapabilities> & netAllCap)165 int32_t NetCapabilitiesChange(sptr<NetHandle> &netHandle, const sptr<NetAllCapabilities> &netAllCap)
166 {
167 return 0;
168 }
169
NetConnectionPropertiesChange(sptr<NetHandle> & netHandle,const sptr<NetLinkInfo> & info)170 int32_t NetConnectionPropertiesChange(sptr<NetHandle> &netHandle, const sptr<NetLinkInfo> &info)
171 {
172 return 0;
173 }
174
NetLost(sptr<NetHandle> & netHandle)175 int32_t NetLost(sptr<NetHandle> &netHandle)
176 {
177 return 0;
178 }
179
NetUnavailable()180 int32_t NetUnavailable()
181 {
182 return 0;
183 }
184
NetBlockStatusChange(sptr<NetHandle> & netHandle,bool blocked)185 int32_t NetBlockStatusChange(sptr<NetHandle> &netHandle, bool blocked)
186 {
187 return 0;
188 }
189 };
190
191 class NetSupplierCallbackBaseTest : public NetSupplierCallbackStub {
192 };
193
194 static bool g_isInited = false;
Init()195 void Init()
196 {
197 if (!g_isInited) {
198 if (!DelayedSingleton<NetConnService>::GetInstance()->Init()) {
199 g_isInited = false;
200 } else {
201 g_isInited = true;
202 }
203 }
204 }
205
OnRemoteRequest(uint32_t code,MessageParcel & data)206 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
207 {
208 if (!g_isInited) {
209 Init();
210 }
211
212 MessageParcel reply;
213 MessageOption option;
214
215 int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
216 return ret;
217 }
218
WriteInterfaceToken(MessageParcel & data)219 bool WriteInterfaceToken(MessageParcel &data)
220 {
221 if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
222 return false;
223 }
224 return true;
225 }
226
SystemReadyFuzzTest(const uint8_t * data,size_t size)227 void SystemReadyFuzzTest(const uint8_t *data, size_t size)
228 {
229 AccessToken token;
230
231 MessageParcel dataParcel;
232 if (!WriteInterfaceToken(dataParcel)) {
233 return;
234 }
235 OnRemoteRequest(INetConnService::CMD_NM_SYSTEM_READY, dataParcel);
236 }
237
RegisterNetSupplierFuzzTest(const uint8_t * data,size_t size)238 void RegisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
239 {
240 if ((data == nullptr) || (size == 0)) {
241 return;
242 }
243 g_baseFuzzData = data;
244 g_baseFuzzSize = size;
245 g_baseFuzzPos = 0;
246
247 AccessToken token;
248 MessageParcel dataParcel;
249 if (!WriteInterfaceToken(dataParcel)) {
250 return;
251 }
252 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
253 dataParcel.ReadUint32(bearerType);
254
255 std::string ident = GetStringFromData(STR_LEN);
256 dataParcel.WriteString(ident);
257
258 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
259 for (auto netCap : netCaps) {
260 dataParcel.WriteUint32(static_cast<uint32_t>(netCap));
261 }
262
263 OnRemoteRequest(INetConnService::CMD_NM_REG_NET_SUPPLIER, dataParcel);
264 }
265
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)266 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
267 {
268 if ((data == nullptr) || (size == 0)) {
269 return;
270 }
271 g_baseFuzzData = data;
272 g_baseFuzzSize = size;
273 g_baseFuzzPos = 0;
274
275 AccessToken token;
276 uint32_t supplierId = GetData<uint32_t>();
277 MessageParcel dataParcel;
278 if (!WriteInterfaceToken(dataParcel)) {
279 return;
280 }
281 dataParcel.WriteUint32(supplierId);
282 OnRemoteRequest(INetConnService::CMD_NM_UNREG_NETWORK, dataParcel);
283 }
284
HasDefaultNetFuzzTest(const uint8_t * data,size_t size)285 void HasDefaultNetFuzzTest(const uint8_t *data, size_t size)
286 {
287 if ((data == nullptr) || (size == 0)) {
288 return;
289 }
290 g_baseFuzzData = data;
291 g_baseFuzzSize = size;
292 g_baseFuzzPos = 0;
293
294 AccessToken token;
295
296 MessageParcel dataParcel;
297 if (!WriteInterfaceToken(dataParcel)) {
298 return;
299 }
300
301 OnRemoteRequest(INetConnService::CMD_NM_HASDEFAULTNET, dataParcel);
302 }
303
GetAllNetsFuzzTest(const uint8_t * data,size_t size)304 void GetAllNetsFuzzTest(const uint8_t *data, size_t size)
305 {
306 if ((data == nullptr) || (size == 0)) {
307 return;
308 }
309 AccessToken token;
310
311 MessageParcel dataParcel;
312 if (!WriteInterfaceToken(dataParcel)) {
313 return;
314 }
315
316 OnRemoteRequest(INetConnService::CMD_NM_GET_ALL_NETS, dataParcel);
317 }
318
BindSocketFuzzTest(const uint8_t * data,size_t size)319 void BindSocketFuzzTest(const uint8_t *data, size_t size)
320 {
321 if ((data == nullptr) || (size == 0)) {
322 return;
323 }
324 g_baseFuzzData = data;
325 g_baseFuzzSize = size;
326 g_baseFuzzPos = 0;
327
328 AccessToken token;
329 int32_t socket_fd = GetData<int32_t>();
330 int32_t netId = GetData<int32_t>();
331 MessageParcel dataParcel;
332 if (!WriteInterfaceToken(dataParcel)) {
333 return;
334 }
335 dataParcel.WriteInt32(socket_fd);
336 dataParcel.WriteInt32(netId);
337 OnRemoteRequest(INetConnService::CMD_NM_BIND_SOCKET, dataParcel);
338 }
339
SetAirplaneModeFuzzTest(const uint8_t * data,size_t size)340 void SetAirplaneModeFuzzTest(const uint8_t *data, size_t size)
341 {
342 if ((data == nullptr) || (size == 0)) {
343 return;
344 }
345 g_baseFuzzData = data;
346 g_baseFuzzSize = size;
347 g_baseFuzzPos = 0;
348
349 AccessToken token;
350 bool state = GetData<bool>();
351
352 MessageParcel dataParcel;
353 if (!WriteInterfaceToken(dataParcel)) {
354 return;
355 }
356 dataParcel.WriteBool(state);
357 OnRemoteRequest(INetConnService::CMD_NM_SET_AIRPLANE_MODE, dataParcel);
358 }
359
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)360 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
361 {
362 if ((data == nullptr) || (size == 0)) {
363 return;
364 }
365 g_baseFuzzData = data;
366 g_baseFuzzSize = size;
367 g_baseFuzzPos = 0;
368
369 AccessToken token;
370 uint32_t supplierId = GetData<uint32_t>();
371 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
372
373 MessageParcel dataParcel;
374 if (!WriteInterfaceToken(dataParcel)) {
375 return;
376 }
377 dataParcel.WriteUint32(supplierId);
378 netSupplierInfo->Marshalling(dataParcel);
379 OnRemoteRequest(INetConnService::CMD_NM_SET_NET_SUPPLIER_INFO, dataParcel);
380 }
381
GetAddressByNameFuzzTest(const uint8_t * data,size_t size)382 void GetAddressByNameFuzzTest(const uint8_t *data, size_t size)
383 {
384 if ((data == nullptr) || (size == 0)) {
385 return;
386 }
387 g_baseFuzzData = data;
388 g_baseFuzzSize = size;
389 g_baseFuzzPos = 0;
390
391 AccessToken token;
392 std::string host = GetStringFromData(STR_LEN);
393 int32_t netId = GetData<int32_t>();
394
395 MessageParcel dataParcel;
396 if (!WriteInterfaceToken(dataParcel)) {
397 return;
398 }
399 dataParcel.WriteString(host);
400 dataParcel.WriteInt32(netId);
401
402 OnRemoteRequest(INetConnService::CMD_NM_GET_ADDRESS_BY_NAME, dataParcel);
403 }
404
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)405 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
406 {
407 if ((data == nullptr) || (size == 0)) {
408 return;
409 }
410 g_baseFuzzData = data;
411 g_baseFuzzSize = size;
412 g_baseFuzzPos = 0;
413
414 AccessToken token;
415 std::string host = GetStringFromData(STR_LEN);
416 int32_t netId = GetData<int32_t>();
417
418 MessageParcel dataParcel;
419 if (!WriteInterfaceToken(dataParcel)) {
420 return;
421 }
422 dataParcel.WriteString(host);
423 dataParcel.WriteInt32(netId);
424
425 OnRemoteRequest(INetConnService::CMD_NM_GET_ADDRESSES_BY_NAME, dataParcel);
426 }
427
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)428 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
429 {
430 if ((data == nullptr) || (size == 0)) {
431 return;
432 }
433 g_baseFuzzData = data;
434 g_baseFuzzSize = size;
435 g_baseFuzzPos = 0;
436
437 uint32_t supplierId = GetData<uint32_t>();
438 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
439 if (netLinkInfo == nullptr) {
440 return;
441 }
442
443 MessageParcel dataParcel;
444 if (!WriteInterfaceToken(dataParcel)) {
445 return;
446 }
447 dataParcel.WriteUint32(supplierId);
448 netLinkInfo->Marshalling(dataParcel);
449
450 OnRemoteRequest(INetConnService::CMD_NM_SET_NET_LINK_INFO, dataParcel);
451 }
452
RegisterNetSupplierCallbackFuzzTest(const uint8_t * data,size_t size)453 void RegisterNetSupplierCallbackFuzzTest(const uint8_t *data, size_t size)
454 {
455 if ((data == nullptr) || (size == 0)) {
456 return;
457 }
458 g_baseFuzzData = data;
459 g_baseFuzzSize = size;
460 g_baseFuzzPos = 0;
461
462 AccessToken token;
463 uint32_t supplierId = GetData<uint32_t>();
464 sptr<NetSupplierCallbackBaseTest> callback = new (std::nothrow) NetSupplierCallbackBaseTest();
465 if (callback == nullptr) {
466 return;
467 }
468
469 MessageParcel dataParcel;
470 if (!WriteInterfaceToken(dataParcel)) {
471 return;
472 }
473 dataParcel.WriteUint32(supplierId);
474 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
475
476 OnRemoteRequest(INetConnService::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK, dataParcel);
477 }
478
RegisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)479 void RegisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
480 {
481 if ((data == nullptr) || (size == 0)) {
482 return;
483 }
484 g_baseFuzzData = data;
485 g_baseFuzzSize = size;
486 g_baseFuzzPos = 0;
487
488 AccessToken token;
489 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
490 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
491 if (netSpecifier == nullptr || callback == nullptr) {
492 return;
493 }
494 uint32_t timeoutMS = GetData<uint32_t>();
495
496 MessageParcel dataParcel;
497 if (!WriteInterfaceToken(dataParcel)) {
498 return;
499 }
500 netSpecifier->Marshalling(dataParcel);
501 dataParcel.WriteUint32(timeoutMS);
502 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
503
504 OnRemoteRequest(INetConnService::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER, dataParcel);
505 }
506
UnregisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)507 void UnregisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
508 {
509 if ((data == nullptr) || (size == 0)) {
510 return;
511 }
512
513 AccessToken token;
514 sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
515 if (callback == nullptr) {
516 return;
517 }
518
519 MessageParcel dataParcel;
520 if (!WriteInterfaceToken(dataParcel)) {
521 return;
522 }
523 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
524
525 OnRemoteRequest(INetConnService::CMD_NM_UNREGISTER_NET_CONN_CALLBACK, dataParcel);
526 }
527
GetDefaultNetFuzzTest(const uint8_t * data,size_t size)528 void GetDefaultNetFuzzTest(const uint8_t *data, size_t size)
529 {
530 if ((data == nullptr) || (size == 0)) {
531 return;
532 }
533 g_baseFuzzData = data;
534 g_baseFuzzSize = size;
535 g_baseFuzzPos = 0;
536
537 AccessToken token;
538
539 MessageParcel dataParcel;
540 if (!WriteInterfaceToken(dataParcel)) {
541 return;
542 }
543 OnRemoteRequest(INetConnService::CMD_NM_GETDEFAULTNETWORK, dataParcel);
544 }
545
GetConnectionPropertiesFuzzTest(const uint8_t * data,size_t size)546 void GetConnectionPropertiesFuzzTest(const uint8_t *data, size_t size)
547 {
548 if ((data == nullptr) || (size == 0)) {
549 return;
550 }
551 g_baseFuzzData = data;
552 g_baseFuzzSize = size;
553 g_baseFuzzPos = 0;
554
555 AccessToken token;
556 int32_t netId = GetData<int32_t>();
557
558 MessageParcel dataParcel;
559 if (!WriteInterfaceToken(dataParcel)) {
560 return;
561 }
562 dataParcel.WriteInt32(netId);
563 OnRemoteRequest(INetConnService::CMD_NM_GET_CONNECTION_PROPERTIES, dataParcel);
564 }
565
GetNetCapabilitiesFuzzTest(const uint8_t * data,size_t size)566 void GetNetCapabilitiesFuzzTest(const uint8_t *data, size_t size)
567 {
568 if ((data == nullptr) || (size == 0)) {
569 return;
570 }
571 g_baseFuzzData = data;
572 g_baseFuzzSize = size;
573 g_baseFuzzPos = 0;
574
575 AccessToken token;
576 int32_t netId = GetData<int32_t>();
577
578 MessageParcel dataParcel;
579 if (!WriteInterfaceToken(dataParcel)) {
580 return;
581 }
582 dataParcel.WriteInt32(netId);
583 OnRemoteRequest(INetConnService::CMD_NM_GET_NET_CAPABILITIES, dataParcel);
584 }
585
NetDetectionFuzzTest(const uint8_t * data,size_t size)586 void NetDetectionFuzzTest(const uint8_t *data, size_t size)
587 {
588 if ((data == nullptr) || (size == 0)) {
589 return;
590 }
591 g_baseFuzzData = data;
592 g_baseFuzzSize = size;
593 g_baseFuzzPos = 0;
594
595 AccessTokenInternetInfo tokenInternetInfo;
596 int32_t netId = GetData<int32_t>();
597
598 MessageParcel dataParcel;
599 if (!WriteInterfaceToken(dataParcel)) {
600 return;
601 }
602 dataParcel.WriteInt32(netId);
603 OnRemoteRequest(INetConnService::CMD_NM_NET_DETECTION, dataParcel);
604 }
605
IsDefaultNetMeteredFuzzTest(const uint8_t * data,size_t size)606 void IsDefaultNetMeteredFuzzTest(const uint8_t *data, size_t size)
607 {
608 if ((data == nullptr) || (size == 0)) {
609 return;
610 }
611 g_baseFuzzData = data;
612 g_baseFuzzSize = size;
613 g_baseFuzzPos = 0;
614 AccessToken token;
615
616 MessageParcel dataParcel;
617 if (!WriteInterfaceToken(dataParcel)) {
618 return;
619 }
620 OnRemoteRequest(INetConnService::CMD_NM_IS_DEFAULT_NET_METERED, dataParcel);
621 }
622
SetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)623 void SetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
624 {
625 if ((data == nullptr) || (size == 0)) {
626 return;
627 }
628 g_baseFuzzData = data;
629 g_baseFuzzSize = size;
630 g_baseFuzzPos = 0;
631 AccessToken token;
632 HttpProxy httpProxy = {GetStringFromData(STR_LEN), 0, {}};
633
634 MessageParcel dataParcel;
635 if (!WriteInterfaceToken(dataParcel)) {
636 return;
637 }
638 httpProxy.Marshalling(dataParcel);
639 OnRemoteRequest(INetConnService::CMD_NM_SET_HTTP_PROXY, dataParcel);
640 }
641
GetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)642 void GetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
643 {
644 if ((data == nullptr) || (size == 0)) {
645 return;
646 }
647 g_baseFuzzData = data;
648 g_baseFuzzSize = size;
649 g_baseFuzzPos = 0;
650 AccessToken token;
651
652 MessageParcel dataParcel;
653 if (!WriteInterfaceToken(dataParcel)) {
654 return;
655 }
656 OnRemoteRequest(INetConnService::CMD_NM_GET_HTTP_PROXY, dataParcel);
657 }
658
GetNetIdByIdentifierFuzzTest(const uint8_t * data,size_t size)659 void GetNetIdByIdentifierFuzzTest(const uint8_t *data, size_t size)
660 {
661 if ((data == nullptr) || (size == 0)) {
662 return;
663 }
664 g_baseFuzzData = data;
665 g_baseFuzzSize = size;
666 g_baseFuzzPos = 0;
667 AccessToken token;
668 std::string ident = GetStringFromData(STR_LEN);
669
670 MessageParcel dataParcel;
671 if (!WriteInterfaceToken(dataParcel)) {
672 return;
673 }
674 dataParcel.WriteString(ident);
675 OnRemoteRequest(INetConnService::CMD_NM_GET_NET_ID_BY_IDENTIFIER, dataParcel);
676 }
677 } // namespace NetManagerStandard
678 } // namespace OHOS
679
680 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)681 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
682 {
683 /* Run your code on data */
684 OHOS::NetManagerStandard::SystemReadyFuzzTest(data, size);
685 OHOS::NetManagerStandard::RegisterNetSupplierFuzzTest(data, size);
686 OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
687 OHOS::NetManagerStandard::RegisterNetSupplierCallbackFuzzTest(data, size);
688 OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
689 OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
690 OHOS::NetManagerStandard::RegisterNetConnCallbackFuzzTest(data, size);
691 OHOS::NetManagerStandard::UnregisterNetConnCallbackFuzzTest(data, size);
692 OHOS::NetManagerStandard::GetDefaultNetFuzzTest(data, size);
693 OHOS::NetManagerStandard::HasDefaultNetFuzzTest(data, size);
694 OHOS::NetManagerStandard::GetAllNetsFuzzTest(data, size);
695 OHOS::NetManagerStandard::GetConnectionPropertiesFuzzTest(data, size);
696 OHOS::NetManagerStandard::GetNetCapabilitiesFuzzTest(data, size);
697 OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
698 OHOS::NetManagerStandard::GetAddressByNameFuzzTest(data, size);
699 OHOS::NetManagerStandard::BindSocketFuzzTest(data, size);
700 OHOS::NetManagerStandard::NetDetectionFuzzTest(data, size);
701 OHOS::NetManagerStandard::SetAirplaneModeFuzzTest(data, size);
702 OHOS::NetManagerStandard::IsDefaultNetMeteredFuzzTest(data, size);
703 OHOS::NetManagerStandard::SetGlobalHttpProxyFuzzTest(data, size);
704 OHOS::NetManagerStandard::GetGlobalHttpProxyFuzzTest(data, size);
705 OHOS::NetManagerStandard::GetNetIdByIdentifierFuzzTest(data, size);
706 return 0;
707 }
708