• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "net_mgr_log_wrapper.h"
32 
33 namespace OHOS {
34 namespace NetManagerStandard {
35 namespace {
36 const uint8_t *g_baseFuzzData = nullptr;
37 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
38 static constexpr uint8_t WITH_ALL_PARM_MODEL = 0;
39 static constexpr uint8_t WITHOUT_FIRST_PARM_MODEL = 1;
40 static constexpr uint8_t WITHOUT_SECOND_PARM_MODEL = 2;
41 static constexpr uint8_t WITHOUT_THIRD_PARM_MODEL = 3;
42 size_t g_baseFuzzSize = 0;
43 size_t g_baseFuzzPos;
44 constexpr size_t STR_LEN = 10;
45 } // namespace
46 
NetConnGetData()47 template <class T> T NetConnGetData()
48 {
49     T object{};
50     size_t netConnSize = sizeof(object);
51     if (g_baseFuzzData == nullptr || netConnSize > g_baseFuzzSize - g_baseFuzzPos) {
52         return object;
53     }
54     errno_t ret = memcpy_s(&object, netConnSize, g_baseFuzzData + g_baseFuzzPos, netConnSize);
55     if (ret != EOK) {
56         return {};
57     }
58     g_baseFuzzPos += netConnSize;
59     return object;
60 }
61 
NetConnGetString(int strlen)62 std::string NetConnGetString(int strlen)
63 {
64     char cstr[strlen];
65     cstr[strlen - 1] = '\0';
66     for (int i = 0; i < strlen - 1; i++) {
67         cstr[i] = NetConnGetData<char>();
68     }
69     std::string str(cstr);
70     return str;
71 }
72 
GetSecureDataFromData(int8_t strlen)73 SecureData GetSecureDataFromData(int8_t strlen)
74 {
75     SecureData secureData;
76     char cstr[strlen];
77     cstr[strlen - 1] = '\0';
78     for (int i = 0; i < strlen - 1; i++) {
79         cstr[i] = NetConnGetData<char>();
80     }
81     secureData.append(cstr, strlen-1);
82     return secureData;
83 }
84 
85 class INetDetectionCallbackTest : public IRemoteStub<INetDetectionCallback> {
86 public:
OnNetDetectionResultChanged(NetDetectionResultCode detectionResult,const std::string & urlRedirect)87     virtual int32_t OnNetDetectionResultChanged(NetDetectionResultCode detectionResult, const std::string &urlRedirect)
88     {
89         return 0;
90     }
91 };
92 
93 class NetInterfaceStateCallbackTest : public NetInterfaceStateCallbackStub {};
94 
95 static bool g_isInited = false;
Init()96 void Init()
97 {
98     if (!g_isInited) {
99         if (!DelayedSingleton<NetConnService>::GetInstance()->Init()) {
100             g_isInited = false;
101         } else {
102             g_isInited = true;
103         }
104     }
105 }
106 
OnRemoteRequest(uint32_t code,MessageParcel & data)107 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
108 {
109     if (!g_isInited) {
110         NETMGR_LOG_D("Net conn client fuzz test g_isInited is false.");
111         Init();
112     }
113 
114     MessageParcel reply;
115     MessageOption option;
116 
117     int32_t ret = DelayedSingleton<NetConnService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
118     return ret;
119 }
120 
WriteInterfaceToken(MessageParcel & data)121 bool WriteInterfaceToken(MessageParcel &data)
122 {
123     if (!data.WriteInterfaceToken(NetConnServiceStub::GetDescriptor())) {
124         NETMGR_LOG_D("Write token failed.");
125         return false;
126     }
127     return true;
128 }
129 
IsConnClientDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)130 bool IsConnClientDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
131 {
132     g_baseFuzzData = data;
133     g_baseFuzzSize = size;
134     g_baseFuzzPos = 0;
135 
136     if (!WriteInterfaceToken(dataParcel)) {
137         return false;
138     }
139     return true;
140 }
141 
SetAppHttpProxyCallback(const HttpProxy & httpProxy)142 void SetAppHttpProxyCallback(const HttpProxy &httpProxy)
143 {
144     return;
145 }
146 
SystemReadyFuzzTest(const uint8_t * data,size_t size)147 void SystemReadyFuzzTest(const uint8_t *data, size_t size)
148 {
149     NetManagerBaseAccessToken token;
150 
151     MessageParcel dataParcel;
152     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
153         return;
154     }
155     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SYSTEM_READY), dataParcel);
156 }
157 
RegisterNetSupplierFuzzTest(const uint8_t * data,size_t size)158 void RegisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
159 {
160     NetManagerBaseAccessToken token;
161     MessageParcel dataParcel;
162     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
163         return;
164     }
165     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
166     dataParcel.WriteUint32(bearerType);
167 
168     std::string ident = NetConnGetString(STR_LEN);
169     dataParcel.WriteString(ident);
170 
171     std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
172     uint32_t capsSize = static_cast<uint32_t>(netCaps.size());
173     dataParcel.WriteUint32(capsSize);
174     for (auto netCap : netCaps) {
175         dataParcel.WriteUint32(static_cast<uint32_t>(netCap));
176     }
177 
178     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REG_NET_SUPPLIER), dataParcel);
179 }
180 
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)181 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
182 {
183     NetManagerBaseAccessToken token;
184     uint32_t supplierId = NetConnGetData<uint32_t>();
185     MessageParcel dataParcel;
186     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
187         return;
188     }
189     dataParcel.WriteUint32(supplierId);
190     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREG_NETWORK), dataParcel);
191 }
192 
HasDefaultNetFuzzTest(const uint8_t * data,size_t size)193 void HasDefaultNetFuzzTest(const uint8_t *data, size_t size)
194 {
195     NetManagerBaseAccessToken token;
196 
197     MessageParcel dataParcel;
198     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
199         return;
200     }
201 
202     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_HASDEFAULTNET), dataParcel);
203 }
204 
GetAllNetsFuzzTest(const uint8_t * data,size_t size)205 void GetAllNetsFuzzTest(const uint8_t *data, size_t size)
206 {
207     if (data == nullptr) {
208         return;
209     }
210     NetManagerBaseAccessToken token;
211 
212     MessageParcel dataParcel;
213     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
214         return;
215     }
216 
217     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ALL_NETS), dataParcel);
218 }
219 
BindSocketFuzzTest(const uint8_t * data,size_t size)220 void BindSocketFuzzTest(const uint8_t *data, size_t size)
221 {
222     NetManagerBaseAccessToken token;
223     int32_t socketFd = NetConnGetData<int32_t>();
224     int32_t netId = NetConnGetData<int32_t>();
225     MessageParcel dataParcel;
226     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
227         return;
228     }
229     dataParcel.WriteInt32(socketFd);
230     dataParcel.WriteInt32(netId);
231     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_BIND_SOCKET), dataParcel);
232 }
233 
SetAirplaneModeFuzzTest(const uint8_t * data,size_t size)234 void SetAirplaneModeFuzzTest(const uint8_t *data, size_t size)
235 {
236     NetManagerBaseAccessToken token;
237     bool state = NetConnGetData<bool>();
238 
239     MessageParcel dataParcel;
240     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
241         return;
242     }
243     dataParcel.WriteBool(state);
244     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcel);
245 
246     MessageParcel dataParcelNoState;
247     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoState)) {
248         return;
249     }
250 
251     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_AIRPLANE_MODE), dataParcelNoState);
252 }
253 
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)254 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
255 {
256     NetManagerBaseAccessToken token;
257     uint32_t supplierId = NetConnGetData<uint32_t>();
258     sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
259 
260     MessageParcel dataParcel;
261     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
262         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
263         return;
264     }
265     dataParcel.WriteUint32(supplierId);
266     netSupplierInfo->Marshalling(dataParcel);
267     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
268 
269     MessageParcel dataParcelNoSupplierId;
270     netSupplierInfo->Marshalling(dataParcel);
271     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_SUPPLIER_INFO), dataParcel);
272 }
273 
GetAddressByNameFuzzTest(const uint8_t * data,size_t size)274 void GetAddressByNameFuzzTest(const uint8_t *data, size_t size)
275 {
276     NetManagerBaseAccessToken token;
277     std::string host = NetConnGetString(STR_LEN);
278     int32_t netId = NetConnGetData<int32_t>();
279 
280     MessageParcel dataParcel;
281     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
282         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
283         return;
284     }
285     dataParcel.WriteString(host);
286     dataParcel.WriteInt32(netId);
287 
288     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcel);
289 
290     MessageParcel dataParcelNoHost;
291     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
292         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
293         return;
294     }
295     dataParcelNoHost.WriteInt32(netId);
296 
297     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoHost);
298 
299     MessageParcel dataParcelNoNetId;
300     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
301         NETMGR_LOG_D("GetAddressByNameFuzzTest write token failed or invalid parameter.");
302         return;
303     }
304     dataParcelNoNetId.WriteInt32(netId);
305 
306     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESS_BY_NAME), dataParcelNoNetId);
307 }
308 
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)309 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
310 {
311     NetManagerBaseAccessToken token;
312     std::string host = NetConnGetString(STR_LEN);
313     int32_t netId = NetConnGetData<int32_t>();
314 
315     MessageParcel dataParcel;
316     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
317         return;
318     }
319     dataParcel.WriteString(host);
320     dataParcel.WriteInt32(netId);
321 
322     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcel);
323 
324     MessageParcel dataParcelNoHost;
325     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoHost)) {
326         return;
327     }
328     dataParcelNoHost.WriteInt32(netId);
329 
330     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoHost);
331 
332     MessageParcel dataParcelNoNetId;
333     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
334         return;
335     }
336     dataParcelNoNetId.WriteString(host);
337 
338     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_ADDRESSES_BY_NAME), dataParcelNoNetId);
339 }
340 
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)341 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
342 {
343     uint32_t supplierId = NetConnGetData<uint32_t>();
344     sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
345     if (netLinkInfo == nullptr) {
346         return;
347     }
348 
349     MessageParcel dataParcel;
350     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
351         return;
352     }
353     dataParcel.WriteUint32(supplierId);
354     netLinkInfo->Marshalling(dataParcel);
355 
356     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcel);
357 
358     MessageParcel dataParcelNoSupplierId;
359     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
360         return;
361     }
362     netLinkInfo->Marshalling(dataParcelNoSupplierId);
363 
364     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_NET_LINK_INFO), dataParcelNoSupplierId);
365 }
366 
RegisterNetSupplierCallbackFuzzTest(const uint8_t * data,size_t size)367 void RegisterNetSupplierCallbackFuzzTest(const uint8_t *data, size_t size)
368 {
369     NetManagerBaseAccessToken token;
370     uint32_t supplierId = NetConnGetData<uint32_t>();
371     sptr<NetSupplierCallbackStubTestCb> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
372     if (callback == nullptr) {
373         return;
374     }
375 
376     MessageParcel dataParcel;
377     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
378         return;
379     }
380     dataParcel.WriteUint32(supplierId);
381     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
382 
383     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK), dataParcel);
384 
385     MessageParcel dataParcelNoSupplierId;
386     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
387         return;
388     }
389     dataParcelNoSupplierId.WriteRemoteObject(callback->AsObject().GetRefPtr());
390 
391     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
392                     dataParcelNoSupplierId);
393 
394     MessageParcel dataParcelNoRemoteObject;
395     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
396         return;
397     }
398     dataParcelNoRemoteObject.WriteUint32(supplierId);
399 
400     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_SUPPLIER_CALLBACK),
401                     dataParcelNoRemoteObject);
402 }
403 
RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t * data,size_t size)404 void RegisterNetConnCallbackBySpecifierFuzzTest(const uint8_t *data, size_t size)
405 {
406     NetManagerBaseAccessToken token;
407     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
408     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
409     if (netSpecifier == nullptr || callback == nullptr) {
410         return;
411     }
412     uint32_t timeoutMS = NetConnGetData<uint32_t>();
413 
414     MessageParcel dataParcel;
415     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
416         return;
417     }
418     netSpecifier->Marshalling(dataParcel);
419     dataParcel.WriteUint32(timeoutMS);
420     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
421 
422     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
423                     dataParcel);
424 
425     MessageParcel dataParcelNoNetSpecifier;
426     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetSpecifier)) {
427         return;
428     }
429     netSpecifier->Marshalling(dataParcelNoNetSpecifier);
430     dataParcelNoNetSpecifier.WriteRemoteObject(callback->AsObject().GetRefPtr());
431 
432     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
433                     dataParcelNoNetSpecifier);
434 
435     MessageParcel dataParcelNoRemoteObject;
436     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
437         return;
438     }
439     netSpecifier->Marshalling(dataParcelNoRemoteObject);
440     dataParcelNoRemoteObject.WriteUint32(timeoutMS);
441 
442     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK_BY_SPECIFIER),
443                     dataParcelNoRemoteObject);
444 }
445 
RegisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)446 void RegisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
447 {
448     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
449     if (callback == nullptr) {
450         return;
451     }
452 
453     MessageParcel dataParcel;
454     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
455         return;
456     }
457 
458     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
459 
460     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK), dataParcel);
461 
462     MessageParcel dataParcelNoRemoteObject;
463     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
464         return;
465     }
466 
467     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_CONN_CALLBACK),
468                     dataParcelNoRemoteObject);
469 }
470 
UnregisterNetConnCallbackFuzzTest(const uint8_t * data,size_t size)471 void UnregisterNetConnCallbackFuzzTest(const uint8_t *data, size_t size)
472 {
473     if (data == nullptr) {
474         return;
475     }
476 
477     NetManagerBaseAccessToken token;
478     sptr<INetConnCallbackTest> callback = new (std::nothrow) INetConnCallbackTest();
479     if (callback == nullptr) {
480         return;
481     }
482 
483     MessageParcel dataParcel;
484     if (!WriteInterfaceToken(dataParcel)) {
485         return;
486     }
487     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
488 
489     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK), dataParcel);
490 
491     MessageParcel dataParcelNoRemoteObject;
492     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
493         return;
494     }
495 
496     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_CONN_CALLBACK),
497                     dataParcelNoRemoteObject);
498 }
499 
GetDefaultNetFuzzTest(const uint8_t * data,size_t size)500 void GetDefaultNetFuzzTest(const uint8_t *data, size_t size)
501 {
502     NetManagerBaseAccessToken token;
503 
504     MessageParcel dataParcel;
505     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
506         return;
507     }
508     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GETDEFAULTNETWORK), dataParcel);
509 }
510 
GetConnectionPropertiesFuzzTest(const uint8_t * data,size_t size)511 void GetConnectionPropertiesFuzzTest(const uint8_t *data, size_t size)
512 {
513     NetManagerBaseAccessToken token;
514     int32_t netId = NetConnGetData<int32_t>();
515 
516     MessageParcel dataParcel;
517     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
518         return;
519     }
520     dataParcel.WriteInt32(netId);
521     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcel);
522 
523     MessageParcel dataParcelNoNetId;
524     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
525         return;
526     }
527     dataParcelNoNetId.WriteInt32(netId);
528     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_CONNECTION_PROPERTIES), dataParcelNoNetId);
529 }
530 
GetNetCapabilitiesFuzzTest(const uint8_t * data,size_t size)531 void GetNetCapabilitiesFuzzTest(const uint8_t *data, size_t size)
532 {
533     NetManagerBaseAccessToken token;
534     int32_t netId = NetConnGetData<int32_t>();
535 
536     MessageParcel dataParcel;
537     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
538         return;
539     }
540     dataParcel.WriteInt32(netId);
541     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcel);
542 
543     MessageParcel dataParcelNoNetId;
544     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
545         return;
546     }
547     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_CAPABILITIES), dataParcelNoNetId);
548 }
549 
NetDetectionFuzzTest(const uint8_t * data,size_t size)550 void NetDetectionFuzzTest(const uint8_t *data, size_t size)
551 {
552     NetManagerBaseAccessToken tokenInternetInfo;
553     int32_t netId = NetConnGetData<int32_t>();
554 
555     MessageParcel dataParcel;
556     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
557         return;
558     }
559     dataParcel.WriteInt32(netId);
560     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcel);
561 
562     MessageParcel dataParcelNoNetId;
563     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
564         return;
565     }
566     dataParcelNoNetId.WriteInt32(netId);
567     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_NET_DETECTION), dataParcelNoNetId);
568 }
569 
IsDefaultNetMeteredFuzzTest(const uint8_t * data,size_t size)570 void IsDefaultNetMeteredFuzzTest(const uint8_t *data, size_t size)
571 {
572     NetManagerBaseAccessToken token;
573 
574     MessageParcel dataParcel;
575     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
576         return;
577     }
578     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_DEFAULT_NET_METERED), dataParcel);
579 }
580 
581 
SetAppHttpProxyFuzzTest(const uint8_t * data,size_t size)582 void SetAppHttpProxyFuzzTest(const uint8_t *data, size_t size)
583 {
584     HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
585     MessageParcel dataParcel;
586     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
587         return;
588     }
589     DelayedSingleton<NetConnClient>::GetInstance()->SetAppHttpProxy(httpProxy);
590 }
591 
RegisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)592 void RegisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
593 {
594     uint32_t callbackId = 0;
595     MessageParcel dataParcel;
596     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
597         return;
598     }
599     DelayedSingleton<NetConnClient>::GetInstance()->RegisterAppHttpProxyCallback(SetAppHttpProxyCallback, callbackId);
600 }
601 
UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t * data,size_t size)602 void UnregisterAppHttpProxyCallbackFuzzTest(const uint8_t *data, size_t size)
603 {
604     int32_t callbackId = NetConnGetData<int32_t>();
605     MessageParcel dataParcel;
606     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
607         return;
608     }
609     DelayedSingleton<NetConnClient>::GetInstance()->UnregisterAppHttpProxyCallback(callbackId);
610 }
611 
SetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)612 void SetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
613 {
614     NetManagerBaseAccessToken token;
615     HttpProxy httpProxy = {NetConnGetString(STR_LEN), 0, {}};
616     httpProxy.SetUserName(GetSecureDataFromData(STR_LEN));
617     httpProxy.SetPassword(GetSecureDataFromData(STR_LEN));
618     MessageParcel dataParcel;
619     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
620         return;
621     }
622     httpProxy.Marshalling(dataParcel);
623     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_GLOBAL_HTTP_PROXY), dataParcel);
624 }
625 
GetGlobalHttpProxyFuzzTest(const uint8_t * data,size_t size)626 void GetGlobalHttpProxyFuzzTest(const uint8_t *data, size_t size)
627 {
628     NetManagerBaseAccessToken token;
629 
630     MessageParcel dataParcel;
631     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
632         return;
633     }
634     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_GLOBAL_HTTP_PROXY), dataParcel);
635 }
636 
GetDefaultHttpProxyFuzzTest(const uint8_t * data,size_t size)637 void GetDefaultHttpProxyFuzzTest(const uint8_t *data, size_t size)
638 {
639     NetManagerBaseAccessToken token;
640 
641     MessageParcel dataParcel;
642     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
643         return;
644     }
645     int32_t bindNetId = NetConnGetData<int32_t>();
646     dataParcel.WriteInt32(bindNetId);
647     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_DEFAULT_HTTP_PROXY), dataParcel);
648 }
649 
GetNetIdByIdentifierFuzzTest(const uint8_t * data,size_t size)650 void GetNetIdByIdentifierFuzzTest(const uint8_t *data, size_t size)
651 {
652     NetManagerBaseAccessToken token;
653     std::string ident = NetConnGetString(STR_LEN);
654 
655     MessageParcel dataParcel;
656     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
657         return;
658     }
659     dataParcel.WriteString(ident);
660     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcel);
661 
662     MessageParcel dataParcelNoIdent;
663     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
664         return;
665     }
666     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_NET_ID_BY_IDENTIFIER), dataParcelNoIdent);
667 }
668 
RegisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)669 void RegisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
670 {
671     if (data == nullptr) {
672         return;
673     }
674 
675     NetManagerBaseAccessToken token;
676     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
677     if (callback == nullptr) {
678         return;
679     }
680 
681     MessageParcel dataParcel;
682     if (!WriteInterfaceToken(dataParcel)) {
683         return;
684     }
685     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
686     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK), dataParcel);
687 
688     MessageParcel dataParcelNoRemoteObject;
689     if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
690         return;
691     }
692     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
693         return;
694     }
695     dataParcelNoRemoteObject.WriteRemoteObject(callback->AsObject().GetRefPtr());
696     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_INTERFACE_CALLBACK),
697                     dataParcelNoRemoteObject);
698 }
699 
UnregisterNetInterfaceCallbackFuzzTest(const uint8_t * data,size_t size)700 void UnregisterNetInterfaceCallbackFuzzTest(const uint8_t *data, size_t size)
701 {
702     if (data == nullptr) {
703         return;
704     }
705 
706     NetManagerBaseAccessToken token;
707     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackTest();
708     if (callback == nullptr) {
709         return;
710     }
711 
712     MessageParcel dataParcel;
713     if (!WriteInterfaceToken(dataParcel)) {
714         return;
715     }
716     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
717     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_INTERFACE_CALLBACK),
718                     dataParcel);
719 
720     MessageParcel dataParcelNoRemoteObject;
721     if (!WriteInterfaceToken(dataParcelNoRemoteObject)) {
722         return;
723     }
724     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
725         return;
726     }
727     dataParcelNoRemoteObject.WriteRemoteObject(callback->AsObject().GetRefPtr());
728     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_INTERFACE_CALLBACK),
729                     dataParcelNoRemoteObject);
730 }
731 
GetNetInterfaceConfigurationFuzzTest(const uint8_t * data,size_t size)732 void GetNetInterfaceConfigurationFuzzTest(const uint8_t *data, size_t size)
733 {
734     NetManagerBaseAccessToken token;
735     std::string iface = NetConnGetString(STR_LEN);
736 
737     MessageParcel dataParcel;
738     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
739         return;
740     }
741     dataParcel.WriteString(iface);
742     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcel);
743 
744     MessageParcel dataParcelNoIface;
745     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIface)) {
746         return;
747     }
748     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_INTERFACE_CONFIGURATION), dataParcelNoIface);
749 }
750 
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)751 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
752 {
753     uint32_t uid = NetConnGetData<uint32_t>();
754     uint8_t allow = NetConnGetData<uint8_t>();
755 
756     NetManagerBaseAccessToken token;
757     MessageParcel dataParcel;
758     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
759         return;
760     }
761 
762     dataParcel.WriteUint32(uid);
763     dataParcel.WriteUint8(allow);
764     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcel);
765 
766     MessageParcel dataParcelNoUid;
767     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
768         return;
769     }
770 
771     dataParcelNoUid.WriteUint8(allow);
772     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoUid);
773 
774     MessageParcel dataParcelNoAllow;
775     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoAllow)) {
776         return;
777     }
778 
779     dataParcel.WriteUint32(uid);
780     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERNET_PERMISSION), dataParcelNoAllow);
781 }
782 
UpdateNetStateForTestFuzzTest(const uint8_t * data,size_t size)783 void UpdateNetStateForTestFuzzTest(const uint8_t *data, size_t size)
784 {
785     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
786     if (netSpecifier == nullptr) {
787         return;
788     }
789     auto netState = NetConnGetData<int32_t>();
790 
791     MessageParcel dataParcel;
792     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
793         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
794         return;
795     }
796 
797     netSpecifier->Marshalling(dataParcel);
798     dataParcel.WriteInt32(netState);
799     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcel);
800 
801     MessageParcel dataParcelNoNetState;
802     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetState)) {
803         NETMGR_LOG_D("UpdateNetSupplierInfoFuzzTest write token failed or invalid parameter.");
804         return;
805     }
806 
807     netSpecifier->Marshalling(dataParcelNoNetState);
808     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UPDATE_NET_STATE_FOR_TEST), dataParcelNoNetState);
809 }
810 
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)811 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
812 {
813     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
814 
815     MessageParcel dataParcel;
816     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
817         NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
818         return;
819     }
820 
821     dataParcel.WriteUint32(bearerType);
822 
823     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcel);
824 
825     MessageParcel dataParcelNoBearerType;
826     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
827         NETMGR_LOG_D("GetIfaceNamesFuzzTest write token failed or invalid parameter.");
828         return;
829     }
830 
831     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACE_NAMES), dataParcelNoBearerType);
832 }
833 
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)834 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
835 {
836     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
837     std::string ident = NetConnGetString(STR_LEN);
838 
839     MessageParcel dataParcel;
840     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
841         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
842         return;
843     }
844 
845     dataParcel.WriteUint32(bearerType);
846     dataParcel.WriteString(ident);
847 
848     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcel);
849 
850     MessageParcel dataParcelNoBearerType;
851     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
852         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
853         return;
854     }
855 
856     dataParcelNoBearerType.WriteString(ident);
857 
858     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoBearerType);
859 
860     MessageParcel dataParcelNoIdent;
861     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
862         NETMGR_LOG_D("GetIfaceNameByTypeFuzzTest write token failed or invalid parameter.");
863         return;
864     }
865 
866     dataParcel.WriteUint32(bearerType);
867     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_IFACENAME_BY_TYPE), dataParcelNoIdent);
868 }
869 
RegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)870 void RegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
871 {
872     int32_t netId = NetConnGetData<int32_t>();
873     sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
874     if (callback == nullptr) {
875         return;
876     }
877 
878     MessageParcel dataParcel;
879     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
880         return;
881     }
882 
883     dataParcel.WriteInt32(netId);
884     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
885 
886     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
887                     dataParcel);
888 
889     MessageParcel dataParcelNoNetId;
890     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
891         return;
892     }
893 
894     dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
895 
896     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
897                     dataParcelNoNetId);
898 
899     MessageParcel dataParcelNoRemoteObject;
900     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoRemoteObject)) {
901         return;
902     }
903     dataParcelNoRemoteObject.WriteInt32(netId);
904     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_NET_DETECTION_RET_CALLBACK),
905                     dataParcelNoRemoteObject);
906 }
907 
UnRegisterNetDetectionCallbackFuzzTest(const uint8_t * data,size_t size)908 void UnRegisterNetDetectionCallbackFuzzTest(const uint8_t *data, size_t size)
909 {
910     int32_t netId = NetConnGetData<int32_t>();
911     sptr<INetDetectionCallbackTest> callback = new (std::nothrow) INetDetectionCallbackTest();
912     if (callback == nullptr) {
913         return;
914     }
915 
916     MessageParcel dataParcel;
917     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
918         return;
919     }
920 
921     dataParcel.WriteInt32(netId);
922     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
923 
924     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
925                     dataParcel);
926 
927     MessageParcel dataParcelNoNetId;
928     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
929         return;
930     }
931 
932     dataParcelNoNetId.WriteRemoteObject(callback->AsObject().GetRefPtr());
933 
934     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
935                     dataParcelNoNetId);
936 
937     MessageParcel dataParcelNoRemoteObject;
938     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
939         return;
940     }
941 
942     dataParcelNoRemoteObject.WriteInt32(netId);
943 
944     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_NET_DETECTION_RET_CALLBACK),
945                     dataParcelNoRemoteObject);
946 }
947 
GetSpecificNetFuzzTest(const uint8_t * data,size_t size)948 void GetSpecificNetFuzzTest(const uint8_t *data, size_t size)
949 {
950     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
951 
952     MessageParcel dataParcel;
953     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
954         return;
955     }
956 
957     dataParcel.WriteUint32(bearerType);
958 
959     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcel);
960 
961     MessageParcel dataParcelNoBearerType;
962     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
963         return;
964     }
965 
966     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET), dataParcelNoBearerType);
967 }
968 
GetSpecificNetByIdentFuzzTest(const uint8_t * data,size_t size)969 void GetSpecificNetByIdentFuzzTest(const uint8_t *data, size_t size)
970 {
971     uint32_t bearerType = NetConnGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
972     std::string ident = NetConnGetString(STR_LEN);
973 
974     MessageParcel dataParcel;
975     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
976         return;
977     }
978 
979     dataParcel.WriteUint32(bearerType);
980     dataParcel.WriteString(ident);
981 
982     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcel);
983 
984     MessageParcel dataParcelNoBearerType;
985     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoBearerType)) {
986         return;
987     }
988     dataParcel.WriteString(ident);
989 
990     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcelNoBearerType);
991 
992     MessageParcel dataParcelNoIdent;
993     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIdent)) {
994         return;
995     }
996     dataParcel.WriteUint32(bearerType);
997 
998     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_NET_BY_IDENT), dataParcelNoIdent);
999 }
1000 
OnSetAppNetFuzzTest(const uint8_t * data,size_t size)1001 void OnSetAppNetFuzzTest(const uint8_t *data, size_t size)
1002 {
1003     int32_t netId = NetConnGetData<int32_t>();
1004 
1005     MessageParcel dataParcel;
1006     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1007         return;
1008     }
1009 
1010     dataParcel.WriteInt32(netId);
1011 
1012     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcel);
1013 
1014     MessageParcel dataParcelNoNetId;
1015     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1016         return;
1017     }
1018 
1019     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_NET), dataParcelNoNetId);
1020 }
1021 
GetSpecificUidNetFuzzTest(const uint8_t * data,size_t size)1022 void GetSpecificUidNetFuzzTest(const uint8_t *data, size_t size)
1023 {
1024     int32_t uid = NetConnGetData<int32_t>();
1025     int32_t netId = NetConnGetData<int32_t>();
1026 
1027     MessageParcel dataParcel;
1028     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1029         return;
1030     }
1031 
1032     dataParcel.WriteInt32(uid);
1033     dataParcel.WriteInt32(netId);
1034 
1035     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcel);
1036 
1037     MessageParcel dataParcelNoUid;
1038     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUid)) {
1039         return;
1040     }
1041 
1042     dataParcelNoUid.WriteInt32(netId);
1043 
1044     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoUid);
1045 
1046     MessageParcel dataParcelNoNetId;
1047     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1048         return;
1049     }
1050     dataParcel.WriteInt32(uid);
1051     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SPECIFIC_UID_NET), dataParcelNoNetId);
1052 }
1053 
AddNetworkRouteFuzzTest(const uint8_t * data,size_t size)1054 void AddNetworkRouteFuzzTest(const uint8_t *data, size_t size)
1055 {
1056     int32_t netId = NetConnGetData<int32_t>();
1057     std::string ifName = NetConnGetString(STR_LEN);
1058     std::string destination = NetConnGetString(STR_LEN);
1059     std::string nextHop = NetConnGetString(STR_LEN);
1060     MessageParcel dataParcel;
1061     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1062         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1063         return;
1064     }
1065     dataParcel.WriteInt32(netId);
1066     dataParcel.WriteString(ifName);
1067     dataParcel.WriteString(destination);
1068     dataParcel.WriteString(nextHop);
1069     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcel);
1070     MessageParcel dataParcelNoNetId;
1071     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1072         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1073         return;
1074     }
1075     dataParcelNoNetId.WriteString(ifName);
1076     dataParcelNoNetId.WriteString(destination);
1077     dataParcelNoNetId.WriteString(nextHop);
1078     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoNetId);
1079     MessageParcel dataParcelNoIfName;
1080     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1081         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1082         return;
1083     }
1084     dataParcelNoIfName.WriteInt32(netId);
1085     dataParcelNoIfName.WriteString(destination);
1086     dataParcelNoIfName.WriteString(nextHop);
1087     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoIfName);
1088     MessageParcel dataParcelNoDest;
1089     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1090         NETMGR_LOG_D("AddNetworkRouteFuzzTest write token failed or invalid parameter.");
1091         return;
1092     }
1093     dataParcelNoDest.WriteInt32(netId);
1094     dataParcelNoDest.WriteString(ifName);
1095     dataParcelNoDest.WriteString(nextHop);
1096     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ROUTE), dataParcelNoDest);
1097 }
1098 
RemoveNetworkRouteFuzzTest(const uint8_t * data,size_t size)1099 void RemoveNetworkRouteFuzzTest(const uint8_t *data, size_t size)
1100 {
1101     int32_t netId = NetConnGetData<int32_t>();
1102     std::string ifName = NetConnGetString(STR_LEN);
1103     std::string destination = NetConnGetString(STR_LEN);
1104     std::string nextHop = NetConnGetString(STR_LEN);
1105     MessageParcel dataParcel;
1106     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1107         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1108         return;
1109     }
1110     dataParcel.WriteInt32(netId);
1111     dataParcel.WriteString(ifName);
1112     dataParcel.WriteString(destination);
1113     dataParcel.WriteString(nextHop);
1114     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcel);
1115     MessageParcel dataParcelNoNetId;
1116     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoNetId)) {
1117         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1118         return;
1119     }
1120     dataParcelNoNetId.WriteString(ifName);
1121     dataParcelNoNetId.WriteString(destination);
1122     dataParcelNoNetId.WriteString(nextHop);
1123     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoNetId);
1124     MessageParcel dataParcelNoIfName;
1125     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1126         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1127         return;
1128     }
1129     dataParcelNoIfName.WriteInt32(netId);
1130     dataParcelNoIfName.WriteString(destination);
1131     dataParcelNoIfName.WriteString(nextHop);
1132     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoIfName);
1133     MessageParcel dataParcelNoDest;
1134     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoDest)) {
1135         NETMGR_LOG_D("RemoveNetworkRouteFuzzTest write token failed or invalid parameter.");
1136         return;
1137     }
1138     dataParcelNoDest.WriteInt32(netId);
1139     dataParcelNoDest.WriteString(ifName);
1140     dataParcelNoDest.WriteString(nextHop);
1141     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ROUTE), dataParcelNoDest);
1142 }
1143 
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1144 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1145 {
1146     int32_t prefixLength = NetConnGetData<int32_t>();
1147     std::string ifName = NetConnGetString(STR_LEN);
1148     std::string ipAddr = NetConnGetString(STR_LEN);
1149 
1150     MessageParcel dataParcel;
1151     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1152         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1153         return;
1154     }
1155     dataParcel.WriteString(ifName);
1156     dataParcel.WriteString(ipAddr);
1157     dataParcel.WriteInt32(prefixLength);
1158 
1159     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcel);
1160 
1161     MessageParcel dataParcelNoIfName;
1162     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1163         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1164         return;
1165     }
1166     dataParcelNoIfName.WriteString(ipAddr);
1167     dataParcelNoIfName.WriteInt32(prefixLength);
1168 
1169     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIfName);
1170 
1171     MessageParcel dataParcelNoIpAddr;
1172     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1173         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1174         return;
1175     }
1176     dataParcelNoIpAddr.WriteString(ifName);
1177     dataParcelNoIpAddr.WriteInt32(prefixLength);
1178 
1179     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoIpAddr);
1180 
1181     MessageParcel dataParcelNoPrefix;
1182     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1183         NETMGR_LOG_D("AddInterfaceAddressFuzzTest write token failed or invalid parameter.");
1184         return;
1185     }
1186     dataParcelNoPrefix.WriteString(ifName);
1187     dataParcelNoPrefix.WriteString(ipAddr);
1188 
1189     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_NET_ADDRESS), dataParcelNoPrefix);
1190 }
1191 
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)1192 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
1193 {
1194     int32_t prefixLength = NetConnGetData<int32_t>();
1195     std::string ifName = NetConnGetString(STR_LEN);
1196     std::string ipAddr = NetConnGetString(STR_LEN);
1197 
1198     MessageParcel dataParcel;
1199     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1200         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1201         return;
1202     }
1203     dataParcel.WriteString(ifName);
1204     dataParcel.WriteString(ipAddr);
1205     dataParcel.WriteInt32(prefixLength);
1206 
1207     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcel);
1208 
1209     MessageParcel dataParcelNoIfName;
1210     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1211         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1212         return;
1213     }
1214     dataParcelNoIfName.WriteString(ipAddr);
1215     dataParcelNoIfName.WriteInt32(prefixLength);
1216 
1217     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIfName);
1218 
1219     MessageParcel dataParcelNoIpAddr;
1220     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIpAddr)) {
1221         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1222         return;
1223     }
1224     dataParcelNoIpAddr.WriteString(ifName);
1225     dataParcelNoIpAddr.WriteInt32(prefixLength);
1226 
1227     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoIpAddr);
1228 
1229     MessageParcel dataParcelNoPrefix;
1230     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoPrefix)) {
1231         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1232         return;
1233     }
1234     dataParcelNoPrefix.WriteString(ifName);
1235     dataParcelNoPrefix.WriteString(ipAddr);
1236 
1237     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REMOVE_NET_ADDRESS), dataParcelNoPrefix);
1238 }
1239 
StaticArpProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel)1240 void StaticArpProcess(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1241 {
1242     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1243         return;
1244     }
1245 
1246     std::string ipAddr = NetConnGetString(STR_LEN);
1247     std::string macAddr = NetConnGetString(STR_LEN);
1248     std::string ifName = NetConnGetString(STR_LEN);
1249     dataParcel.WriteString(ipAddr);
1250     dataParcel.WriteString(macAddr);
1251     dataParcel.WriteString(ifName);
1252 }
1253 
StaticArpProcessNoIpAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1254 void StaticArpProcessNoIpAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1255 {
1256     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1257         return;
1258     }
1259 
1260     std::string macAddr = NetConnGetString(STR_LEN);
1261     std::string ifName = NetConnGetString(STR_LEN);
1262     dataParcel.WriteString(macAddr);
1263     dataParcel.WriteString(ifName);
1264 }
1265 
StaticArpProcessNoMacAddr(const uint8_t * data,size_t size,MessageParcel & dataParcel)1266 void StaticArpProcessNoMacAddr(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1267 {
1268     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1269         return;
1270     }
1271 
1272     std::string ipAddr = NetConnGetString(STR_LEN);
1273     std::string ifName = NetConnGetString(STR_LEN);
1274     dataParcel.WriteString(ipAddr);
1275     dataParcel.WriteString(ifName);
1276 }
1277 
StaticArpProcessNoIfName(const uint8_t * data,size_t size,MessageParcel & dataParcel)1278 void StaticArpProcessNoIfName(const uint8_t *data, size_t size, MessageParcel &dataParcel)
1279 {
1280     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1281         return;
1282     }
1283 
1284     std::string ipAddr = NetConnGetString(STR_LEN);
1285     std::string macAddr = NetConnGetString(STR_LEN);
1286     dataParcel.WriteString(ipAddr);
1287     dataParcel.WriteString(macAddr);
1288 }
1289 
AddStaticArpFuzzTest(const uint8_t * data,size_t size)1290 void AddStaticArpFuzzTest(const uint8_t *data, size_t size)
1291 {
1292     MessageParcel dataParcel;
1293     StaticArpProcess(data, size, dataParcel);
1294     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcel);
1295 
1296     MessageParcel dataParcelNoIpAddr;
1297     StaticArpProcessNoIpAddr(data, size, dataParcelNoIpAddr);
1298     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIpAddr);
1299 
1300     MessageParcel dataParcelNoMacAddr;
1301     StaticArpProcessNoMacAddr(data, size, dataParcelNoMacAddr);
1302     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoMacAddr);
1303 
1304     MessageParcel dataParcelNoIfName;
1305     StaticArpProcessNoIfName(data, size, dataParcelNoIfName);
1306     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ADD_STATIC_ARP), dataParcelNoIfName);
1307 }
1308 
DelStaticArpFuzzTest(const uint8_t * data,size_t size)1309 void DelStaticArpFuzzTest(const uint8_t *data, size_t size)
1310 {
1311     MessageParcel dataParcel;
1312     StaticArpProcess(data, size, dataParcel);
1313     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcel);
1314 
1315     MessageParcel dataParcelNoIpAddr;
1316     StaticArpProcessNoIpAddr(data, size, dataParcel);
1317     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIpAddr);
1318 
1319     MessageParcel dataParcelNoMacAddr;
1320     StaticArpProcessNoMacAddr(data, size, dataParcel);
1321     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoMacAddr);
1322 
1323     MessageParcel dataParcelNoIfName;
1324     StaticArpProcessNoIfName(data, size, dataParcel);
1325     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DEL_STATIC_ARP), dataParcelNoIfName);
1326 }
1327 
RegisterSlotTypeFuzzTest(const uint8_t * data,size_t size)1328 void RegisterSlotTypeFuzzTest(const uint8_t *data, size_t size)
1329 {
1330     int32_t supplierId = NetConnGetData<int32_t>();
1331     int32_t type = NetConnGetData<int32_t>();
1332 
1333     MessageParcel dataParcel;
1334     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1335         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1336         return;
1337     }
1338     dataParcel.WriteInt32(supplierId);
1339     dataParcel.WriteInt32(type);
1340     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcel);
1341 
1342     MessageParcel dataParcelNoSupplierId;
1343     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoSupplierId)) {
1344         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1345         return;
1346     }
1347     dataParcelNoSupplierId.WriteInt32(type);
1348     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoSupplierId);
1349 
1350     MessageParcel dataParcelNoType;
1351     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoType)) {
1352         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1353         return;
1354     }
1355     dataParcel.WriteInt32(supplierId);
1356     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_SLOT_TYPE), dataParcelNoType);
1357 }
1358 
GetSlotTypeFuzzTest(const uint8_t * data,size_t size)1359 void GetSlotTypeFuzzTest(const uint8_t *data, size_t size)
1360 {
1361     MessageParcel dataParcel;
1362     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1363         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1364         return;
1365     }
1366     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_GET_SLOT_TYPE), dataParcel);
1367 }
1368 
IsPreferCellularUrlFuzzTest(const uint8_t * data,size_t size)1369 void IsPreferCellularUrlFuzzTest(const uint8_t *data, size_t size)
1370 {
1371     std::string url = NetConnGetString(STR_LEN);
1372     MessageParcel dataParcel;
1373     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1374         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1375         return;
1376     }
1377     dataParcel.WriteString(url);
1378     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcel);
1379 
1380     MessageParcel dataParcelNoUrl;
1381     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoUrl)) {
1382         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1383         return;
1384     }
1385     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_IS_PREFER_CELLULAR_URL), dataParcelNoUrl);
1386 }
1387 
StaticDecreaseSupplierScoreProcess(const uint8_t * data,size_t size,MessageParcel & dataParcel,uint8_t paramsModel)1388 void StaticDecreaseSupplierScoreProcess(
1389     const uint8_t *data, size_t size, MessageParcel &dataParcel, uint8_t paramsModel)
1390 {
1391     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1392         return;
1393     }
1394     // ! without the first param.
1395     if (paramsModel != WITHOUT_FIRST_PARM_MODEL) {
1396         int32_t type = NetConnGetData<int32_t>();
1397         dataParcel.WriteInt32(type);
1398     }
1399     // ! without the second param.
1400     if (paramsModel != WITHOUT_SECOND_PARM_MODEL) {
1401         std::string ident = NetConnGetString(STR_LEN);
1402         dataParcel.WriteString(ident);
1403     }
1404     // ! without the third param.
1405     if (paramsModel != WITHOUT_THIRD_PARM_MODEL) {
1406         int32_t supplierId = NetConnGetData<int32_t>();
1407         dataParcel.WriteInt32(supplierId);
1408     }
1409 }
1410 
DecreaseSupplierScoreFuzzTest(const uint8_t * data,size_t size)1411 void DecreaseSupplierScoreFuzzTest(const uint8_t *data, size_t size)
1412 {
1413     MessageParcel dataParcelWithAllParam;
1414     StaticDecreaseSupplierScoreProcess(data, size, dataParcelWithAllParam, WITH_ALL_PARM_MODEL);
1415     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DECREASE_SUPPLIER_SCORE), dataParcelWithAllParam);
1416 
1417     MessageParcel dataParcelWithOutFirstParam;
1418     StaticDecreaseSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_FIRST_PARM_MODEL);
1419     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DECREASE_SUPPLIER_SCORE),
1420                     dataParcelWithOutFirstParam);
1421 
1422     MessageParcel dataParcelWithOutSecondParam;
1423     StaticDecreaseSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_SECOND_PARM_MODEL);
1424     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DECREASE_SUPPLIER_SCORE),
1425                     dataParcelWithOutSecondParam);
1426 
1427     MessageParcel dataParcelWithOutThirdParam;
1428     StaticDecreaseSupplierScoreProcess(data, size, dataParcelWithAllParam, WITHOUT_THIRD_PARM_MODEL);
1429     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DECREASE_SUPPLIER_SCORE),
1430                     dataParcelWithOutThirdParam);
1431 }
1432 
IncreaseSupplierScoreFuzzTest(const uint8_t * data,size_t size)1433 void IncreaseSupplierScoreFuzzTest(const uint8_t *data, size_t size)
1434 {
1435     MessageParcel dataParcelWithAllParam;
1436     if (!IsConnClientDataAndSizeValid(data, size, dataParcelWithAllParam)) {
1437         return;
1438     }
1439     int32_t supplierId = NetConnGetData<int32_t>();
1440     dataParcelWithAllParam.WriteInt32(supplierId);
1441     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_INCREASE_SUPPLIER_SCORE), dataParcelWithAllParam);
1442 
1443     MessageParcel dataParcelWithOutFirstParam;
1444     if (!IsConnClientDataAndSizeValid(data, size, dataParcelWithOutFirstParam)) {
1445         return;
1446     }
1447     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_INCREASE_SUPPLIER_SCORE),
1448                     dataParcelWithOutFirstParam);
1449 }
1450 
RegisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1451 void RegisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1452 {
1453     NetManagerBaseAccessToken token;
1454     sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1455     if (callback == nullptr) {
1456         return;
1457     }
1458 
1459     MessageParcel dataParcel;
1460     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1461         return;
1462     }
1463     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1464 
1465     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1466 
1467     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_REGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1468 }
1469 
UnregisterPreAirplaneCallbackFuzzTest(const uint8_t * data,size_t size)1470 void UnregisterPreAirplaneCallbackFuzzTest(const uint8_t *data, size_t size)
1471 {
1472     NetManagerBaseAccessToken token;
1473     sptr<IPreAirplaneCallbackStubTestCb> callback = new (std::nothrow) IPreAirplaneCallbackStubTestCb();
1474     if (callback == nullptr) {
1475         return;
1476     }
1477 
1478     MessageParcel dataParcel;
1479     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1480         return;
1481     }
1482     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1483 
1484     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
1485 
1486     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_UNREGISTER_PREAIRPLANE_CALLBACK), dataParcel);
1487 }
1488 
EnableDistributedClientNetFuzzTest(const uint8_t * data,size_t size)1489 void EnableDistributedClientNetFuzzTest(const uint8_t *data, size_t size)
1490 {
1491     std::string virnicAddr = NetConnGetString(STR_LEN);
1492     std::string iif = NetConnGetString(STR_LEN);
1493     MessageParcel dataParcel;
1494     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1495         NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1496         return;
1497     }
1498     dataParcel.WriteString(virnicAddr);
1499     dataParcel.WriteString(iif);
1500     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_DISTRIBUTE_CLIENT_NET), dataParcel);
1501 }
1502 
EnableDistributedServerNetFuzzTest(const uint8_t * data,size_t size)1503 void EnableDistributedServerNetFuzzTest(const uint8_t *data, size_t size)
1504 {
1505     std::string iif = NetConnGetString(STR_LEN);
1506     std::string devIface = NetConnGetString(STR_LEN);
1507     std::string dstAddr = NetConnGetString(STR_LEN);
1508 
1509     MessageParcel dataParcel;
1510     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1511         NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1512         return;
1513     }
1514     dataParcel.WriteString(iif);
1515     dataParcel.WriteString(devIface);
1516     dataParcel.WriteString(dstAddr);
1517     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_DISTRIBUTE_SERVER_NET), dataParcel);
1518 }
1519 
DisableDistributedNetFuzzTest(const uint8_t * data,size_t size)1520 void DisableDistributedNetFuzzTest(const uint8_t *data, size_t size)
1521 {
1522     bool isServer = NetConnGetData<bool>();
1523     MessageParcel dataParcel;
1524     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1525         NETMGR_LOG_D("EnableDistributedClientNetFuzzTest write token failed or invalid parameter.");
1526         return;
1527     }
1528     dataParcel.WriteBool(isServer);
1529     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_DISABLE_DISTRIBUTE_NET), dataParcel);
1530 }
1531 
CloseSocketsUidTest(const uint8_t * data,size_t size)1532 void CloseSocketsUidTest(const uint8_t *data, size_t size)
1533 {
1534     uint32_t uid = NetConnGetData<uint32_t>();
1535     std::string ipAddr = NetConnGetString(STR_LEN);
1536 
1537     MessageParcel dataParcel;
1538     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1539         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1540         return;
1541     }
1542 
1543     dataParcel.WriteString(ipAddr);
1544     dataParcel.WriteUint32(uid);
1545     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_CLOSE_SOCKETS_UID), dataParcel);
1546 
1547     MessageParcel dataParcelNoIfName;
1548     if (!IsConnClientDataAndSizeValid(data, size, dataParcelNoIfName)) {
1549         NETMGR_LOG_D("DelInterfaceAddressFuzzTest write token failed or invalid parameter.");
1550         return;
1551     }
1552     dataParcelNoIfName.WriteString(ipAddr);
1553     dataParcelNoIfName.WriteUint32(uid);
1554 
1555     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_CLOSE_SOCKETS_UID), dataParcelNoIfName);
1556 }
1557 
SetAppIsFrozenedTest(const uint8_t * data,size_t size)1558 void SetAppIsFrozenedTest(const uint8_t *data, size_t size)
1559 {
1560     uint32_t uid = NetConnGetData<uint32_t>();
1561     bool isFrozened = NetConnGetData<bool>();
1562 
1563     MessageParcel dataParcel;
1564     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1565         NETMGR_LOG_D("SetAppIsFrozenedTest write token failed or invalid parameter.");
1566         return;
1567     }
1568 
1569     dataParcel.WriteUint32(uid);
1570     dataParcel.WriteBool(isFrozened);
1571     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_APP_IS_FROZENED), dataParcel);
1572 }
1573 
EnableAppFrozenedCallbackLimitationTest(const uint8_t * data,size_t size)1574 void EnableAppFrozenedCallbackLimitationTest(const uint8_t *data, size_t size)
1575 {
1576     bool flag = NetConnGetData<bool>();
1577 
1578     MessageParcel dataParcel;
1579     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1580         NETMGR_LOG_D("EnableAppFrozenedCallbackLimitationTest write token failed or invalid parameter.");
1581         return;
1582     }
1583 
1584     dataParcel.WriteBool(flag);
1585     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_ENABLE_APP_FROZENED_CALLBACK_LIMITATION),
1586         dataParcel);
1587 }
1588 
SetInterfaceUpFuzzTest(const uint8_t * data,size_t size)1589 void SetInterfaceUpFuzzTest(const uint8_t *data, size_t size)
1590 {
1591     NetManagerBaseAccessToken token;
1592     std::string iface = NetConnGetString(STR_LEN);
1593     MessageParcel dataParcel;
1594     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1595         return;
1596     }
1597     dataParcel.WriteString(iface);
1598     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_UP), dataParcel);
1599 }
1600 
SetInterfaceDownFuzzTest(const uint8_t * data,size_t size)1601 void SetInterfaceDownFuzzTest(const uint8_t *data, size_t size)
1602 {
1603     NetManagerBaseAccessToken token;
1604     std::string iface = NetConnGetString(STR_LEN);
1605 
1606     MessageParcel dataParcel;
1607     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1608         return;
1609     }
1610 
1611     dataParcel.WriteString(iface);
1612     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_DOWN), dataParcel);
1613 }
1614 
SetNetInterfaceIpAddressFuzzTest(const uint8_t * data,size_t size)1615 void SetNetInterfaceIpAddressFuzzTest(const uint8_t *data, size_t size)
1616 {
1617     NetManagerBaseAccessToken token;
1618     std::string iface = NetConnGetString(STR_LEN);
1619     std::string ipAddr = NetConnGetString(STR_LEN);
1620 
1621     MessageParcel dataParcel;
1622     if (!IsConnClientDataAndSizeValid(data, size, dataParcel)) {
1623         return;
1624     }
1625 
1626     dataParcel.WriteString(iface);
1627     dataParcel.WriteString(ipAddr);
1628     OnRemoteRequest(static_cast<uint32_t>(ConnInterfaceCode::CMD_NM_SET_INTERFACE_IP_ADDRESS), dataParcel);
1629 }
1630 
LLVMFuzzerTestOneInputNew(const uint8_t * data,size_t size)1631 void LLVMFuzzerTestOneInputNew(const uint8_t *data, size_t size)
1632 {
1633     OHOS::NetManagerStandard::SetInterfaceUpFuzzTest(data, size);
1634     OHOS::NetManagerStandard::SetInterfaceDownFuzzTest(data, size);
1635     OHOS::NetManagerStandard::SetNetInterfaceIpAddressFuzzTest(data, size);
1636     OHOS::NetManagerStandard::UnregisterNetInterfaceCallbackFuzzTest(data, size);
1637     OHOS::NetManagerStandard::SetAppIsFrozenedTest(data, size);
1638     OHOS::NetManagerStandard::EnableAppFrozenedCallbackLimitationTest(data, size);
1639     OHOS::NetManagerStandard::GetSpecificNetByIdentFuzzTest(data, size);
1640 }
1641 } // namespace NetManagerStandard
1642 } // namespace OHOS
1643 
1644 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1645 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1646 {
1647     /* Run your code on data */
1648     OHOS::NetManagerStandard::SystemReadyFuzzTest(data, size);
1649     OHOS::NetManagerStandard::RegisterNetSupplierFuzzTest(data, size);
1650     OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
1651     OHOS::NetManagerStandard::RegisterNetSupplierCallbackFuzzTest(data, size);
1652     OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
1653     OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
1654     OHOS::NetManagerStandard::RegisterNetConnCallbackBySpecifierFuzzTest(data, size);
1655     OHOS::NetManagerStandard::RegisterNetConnCallbackFuzzTest(data, size);
1656     OHOS::NetManagerStandard::UnregisterNetConnCallbackFuzzTest(data, size);
1657     OHOS::NetManagerStandard::GetDefaultNetFuzzTest(data, size);
1658     OHOS::NetManagerStandard::HasDefaultNetFuzzTest(data, size);
1659     OHOS::NetManagerStandard::GetAllNetsFuzzTest(data, size);
1660     OHOS::NetManagerStandard::GetConnectionPropertiesFuzzTest(data, size);
1661     OHOS::NetManagerStandard::GetNetCapabilitiesFuzzTest(data, size);
1662     OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
1663     OHOS::NetManagerStandard::GetAddressByNameFuzzTest(data, size);
1664     OHOS::NetManagerStandard::BindSocketFuzzTest(data, size);
1665     OHOS::NetManagerStandard::NetDetectionFuzzTest(data, size);
1666     OHOS::NetManagerStandard::SetAirplaneModeFuzzTest(data, size);
1667     OHOS::NetManagerStandard::IsDefaultNetMeteredFuzzTest(data, size);
1668     OHOS::NetManagerStandard::SetGlobalHttpProxyFuzzTest(data, size);
1669     OHOS::NetManagerStandard::GetGlobalHttpProxyFuzzTest(data, size);
1670     OHOS::NetManagerStandard::GetDefaultHttpProxyFuzzTest(data, size);
1671     OHOS::NetManagerStandard::SetAppHttpProxyFuzzTest(data, size);
1672     OHOS::NetManagerStandard::RegisterAppHttpProxyCallbackFuzzTest(data, size);
1673     OHOS::NetManagerStandard::UnregisterAppHttpProxyCallbackFuzzTest(data, size);
1674     OHOS::NetManagerStandard::GetNetIdByIdentifierFuzzTest(data, size);
1675     OHOS::NetManagerStandard::RegisterNetInterfaceCallbackFuzzTest(data, size);
1676     OHOS::NetManagerStandard::GetNetInterfaceConfigurationFuzzTest(data, size);
1677     OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1678     OHOS::NetManagerStandard::UpdateNetStateForTestFuzzTest(data, size);
1679     OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
1680     OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
1681     OHOS::NetManagerStandard::RegisterNetDetectionCallbackFuzzTest(data, size);
1682     OHOS::NetManagerStandard::UnRegisterNetDetectionCallbackFuzzTest(data, size);
1683     OHOS::NetManagerStandard::GetSpecificNetFuzzTest(data, size);
1684     OHOS::NetManagerStandard::GetSpecificUidNetFuzzTest(data, size);
1685     OHOS::NetManagerStandard::OnSetAppNetFuzzTest(data, size);
1686     OHOS::NetManagerStandard::AddNetworkRouteFuzzTest(data, size);
1687     OHOS::NetManagerStandard::RemoveNetworkRouteFuzzTest(data, size);
1688     OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1689     OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1690     OHOS::NetManagerStandard::AddStaticArpFuzzTest(data, size);
1691     OHOS::NetManagerStandard::DelStaticArpFuzzTest(data, size);
1692     OHOS::NetManagerStandard::EnableDistributedClientNetFuzzTest(data, size);
1693     OHOS::NetManagerStandard::EnableDistributedServerNetFuzzTest(data, size);
1694     OHOS::NetManagerStandard::DisableDistributedNetFuzzTest(data, size);
1695     OHOS::NetManagerStandard::CloseSocketsUidTest(data, size);
1696     OHOS::NetManagerStandard::LLVMFuzzerTestOneInputNew(data, size);
1697     return 0;
1698 }
1699