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