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_notify_callback_test.h"
20 #include "iservice_registry.h"
21 #include "net_dns_health_callback_stub.h"
22 #include "net_dns_result_callback_stub.h"
23 #include "netsys_native_client.h"
24 #include "notify_callback_stub.h"
25 #include "singleton.h"
26 #include "system_ability_definition.h"
27 #define private public
28 #include "iptables_wrapper.h"
29 #include "netsys_native_service.h"
30 #include "netsys_native_service_stub.h"
31 namespace OHOS {
32 namespace NetManagerStandard {
33 namespace {
34 const uint8_t *g_baseFuzzData = nullptr;
35 static constexpr uint32_t CONVERT_NUMBER_TO_BOOL = 2;
36 size_t g_baseFuzzSize = 0;
37 size_t g_baseFuzzPos;
38 constexpr size_t STR_LEN = 10;
39 constexpr size_t VECTOR_MAX_SIZE = 15;
40 } // namespace
41 
NetSysGetData()42 template <class T> T NetSysGetData()
43 {
44     T object{};
45     size_t netSysSize = sizeof(object);
46     if (g_baseFuzzData == nullptr || netSysSize > g_baseFuzzSize - g_baseFuzzPos) {
47         return object;
48     }
49     errno_t ret = memcpy_s(&object, netSysSize, g_baseFuzzData + g_baseFuzzPos, netSysSize);
50     if (ret != EOK) {
51         return {};
52     }
53     g_baseFuzzPos += netSysSize;
54     return object;
55 }
56 
NetSysGetString(int strlen)57 std::string NetSysGetString(int strlen)
58 {
59     char cstr[strlen];
60     cstr[strlen - 1] = '\0';
61     for (int i = 0; i < strlen - 1; i++) {
62         cstr[i] = NetSysGetData<char>();
63     }
64     std::string str(cstr);
65     return str;
66 }
67 
68 static bool g_isInited = false;
69 
Init()70 __attribute__((no_sanitize("cfi"))) void Init()
71 {
72     nmd::IptablesWrapper::GetInstance();
73     if (!DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->Init()) {
74         g_isInited = false;
75     } else {
76         g_isInited = true;
77     }
78 }
79 
OnRemoteRequest(uint32_t code,MessageParcel & data)80 __attribute__((no_sanitize("cfi"))) int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
81 {
82     if (!g_isInited) {
83         Init();
84     }
85 
86     MessageParcel reply;
87     MessageOption option;
88 
89     int32_t ret =
90         DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
91     return ret;
92 }
93 
WriteInterfaceToken(MessageParcel & data)94 bool WriteInterfaceToken(MessageParcel &data)
95 {
96     if (!data.WriteInterfaceToken(NetsysNative::NetsysNativeServiceStub::GetDescriptor())) {
97         return false;
98     }
99     return true;
100 }
101 
WriteInterfaceTokenCallback(MessageParcel & data)102 bool WriteInterfaceTokenCallback(MessageParcel &data)
103 {
104     if (!data.WriteInterfaceToken(NetsysNative::NotifyCallbackStub::GetDescriptor())) {
105         return false;
106     }
107     return true;
108 }
109 
110 class INetSysCallbackTest : public NetsysNative::NotifyCallbackStub {
111 public:
INetSysCallbackTest()112     INetSysCallbackTest() : NotifyCallbackStub() {}
~INetSysCallbackTest()113     virtual ~INetSysCallbackTest() {}
114 };
115 
116 class NetDnsResultCallbackFuzzTest : public NetsysNative::NetDnsResultCallbackStub {
117 public:
118     NetDnsResultCallbackFuzzTest() = default;
~NetDnsResultCallbackFuzzTest()119     ~NetDnsResultCallbackFuzzTest() override{};
120 
OnDnsResultReport(uint32_t size,const std::list<NetsysNative::NetDnsResultReport>)121     int32_t OnDnsResultReport(uint32_t size, const std::list<NetsysNative::NetDnsResultReport>) override
122     {
123         return 0;
124     }
125 };
126 
127 class TestNetDnsHealthCallbackFuzzTest : public NetsysNative::NetDnsHealthCallbackStub {
128 public:
129     TestNetDnsHealthCallbackFuzzTest() = default;
~TestNetDnsHealthCallbackFuzzTest()130     ~TestNetDnsHealthCallbackFuzzTest() override{};
131 
OnDnsHealthReport(const NetsysNative::NetDnsHealthReport & dnsHealthReport)132     int32_t OnDnsHealthReport(const NetsysNative::NetDnsHealthReport &dnsHealthReport) override
133     {
134         return 0;
135     }
136 };
137 
138 static NetsysNative::NetsysNativeService g_netSysNativeClient;
139 
IsDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)140 bool IsDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
141 {
142     if ((data == nullptr) || (size == 0)) {
143         return false;
144     }
145     g_baseFuzzData = data;
146     g_baseFuzzSize = size;
147     g_baseFuzzPos = 0;
148 
149     if (!WriteInterfaceToken(dataParcel)) {
150         return false;
151     }
152     return true;
153 }
154 
NetworkCreatePhysicalFuzzTest(const uint8_t * data,size_t size)155 __attribute__((no_sanitize("cfi"))) void NetworkCreatePhysicalFuzzTest(const uint8_t *data, size_t size)
156 {
157     MessageParcel dataParcel;
158     if (!IsDataAndSizeValid(data, size, dataParcel)) {
159         return;
160     }
161 
162     int32_t netId = NetSysGetData<int32_t>();
163     int32_t permission = NetSysGetData<int32_t>();
164 
165     dataParcel.WriteInt32(netId);
166     dataParcel.WriteInt32(permission);
167     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_PHYSICAL),
168                     dataParcel);
169 }
170 
NetworkDestroyFuzzTest(const uint8_t * data,size_t size)171 void NetworkDestroyFuzzTest(const uint8_t *data, size_t size)
172 {
173     MessageParcel dataParcel;
174     if (!IsDataAndSizeValid(data, size, dataParcel)) {
175         return;
176     }
177 
178     int32_t netId = NetSysGetData<int32_t>();
179     dataParcel.WriteInt32(netId);
180     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DESTROY), dataParcel);
181 }
182 
NetworkAddInterfaceFuzzTest(const uint8_t * data,size_t size)183 void NetworkAddInterfaceFuzzTest(const uint8_t *data, size_t size)
184 {
185     MessageParcel dataParcel;
186     if (!IsDataAndSizeValid(data, size, dataParcel)) {
187         return;
188     }
189 
190     int32_t netId = NetSysGetData<int32_t>();
191     std::string iface = NetSysGetString(STR_LEN);
192 
193     dataParcel.WriteInt32(netId);
194     dataParcel.WriteString(iface);
195     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_INTERFACE), dataParcel);
196 }
197 
NetworkRemoveInterfaceFuzzTest(const uint8_t * data,size_t size)198 void NetworkRemoveInterfaceFuzzTest(const uint8_t *data, size_t size)
199 {
200     MessageParcel dataParcel;
201     if (!IsDataAndSizeValid(data, size, dataParcel)) {
202         return;
203     }
204 
205     int32_t netId = NetSysGetData<int32_t>();
206     std::string iface = NetSysGetString(STR_LEN);
207 
208     dataParcel.WriteInt32(netId);
209     dataParcel.WriteString(iface);
210     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_INTERFACE),
211                     dataParcel);
212 }
213 
NetworkAddRouteFuzzTest(const uint8_t * data,size_t size)214 void NetworkAddRouteFuzzTest(const uint8_t *data, size_t size)
215 {
216     MessageParcel dataParcel;
217     if (!IsDataAndSizeValid(data, size, dataParcel)) {
218         return;
219     }
220 
221     int32_t netId = NetSysGetData<int32_t>();
222     std::string ifName = NetSysGetString(STR_LEN);
223     std::string destination = NetSysGetString(STR_LEN);
224     std::string nextHop = NetSysGetString(STR_LEN);
225 
226     dataParcel.WriteInt32(netId);
227     dataParcel.WriteString(ifName);
228     dataParcel.WriteString(destination);
229     dataParcel.WriteString(nextHop);
230     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE), dataParcel);
231 }
232 
NetworkRemoveRouteFuzzTest(const uint8_t * data,size_t size)233 void NetworkRemoveRouteFuzzTest(const uint8_t *data, size_t size)
234 {
235     MessageParcel dataParcel;
236     if (!IsDataAndSizeValid(data, size, dataParcel)) {
237         return;
238     }
239 
240     int32_t netId = NetSysGetData<int32_t>();
241     std::string ifName = NetSysGetString(STR_LEN);
242     std::string destination = NetSysGetString(STR_LEN);
243     std::string nextHop = NetSysGetString(STR_LEN);
244 
245     dataParcel.WriteInt32(netId);
246     dataParcel.WriteString(ifName);
247     dataParcel.WriteString(destination);
248     dataParcel.WriteString(nextHop);
249     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_ROUTE), dataParcel);
250 }
251 
GetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)252 void GetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
253 {
254     MessageParcel dataParcel;
255     if (!IsDataAndSizeValid(data, size, dataParcel)) {
256         return;
257     }
258 
259     OHOS::nmd::InterfaceConfigurationParcel cfg;
260     cfg.ifName = NetSysGetString(STR_LEN);
261 
262     dataParcel.WriteString(cfg.ifName);
263     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_CONFIG), dataParcel);
264 }
265 
GetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)266 void GetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
267 {
268     MessageParcel dataParcel;
269     if (!IsDataAndSizeValid(data, size, dataParcel)) {
270         return;
271     }
272 
273     std::string interfaceName = NetSysGetString(STR_LEN);
274 
275     dataParcel.WriteString(interfaceName);
276     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_MTU), dataParcel);
277 }
278 
SetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)279 void SetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
280 {
281     MessageParcel dataParcel;
282     if (!IsDataAndSizeValid(data, size, dataParcel)) {
283         return;
284     }
285 
286     int32_t mtu = NetSysGetData<int32_t>();
287     std::string interfaceName = NetSysGetString(STR_LEN);
288 
289     dataParcel.WriteString(interfaceName);
290     dataParcel.WriteInt32(mtu);
291     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_MTU), dataParcel);
292 }
293 
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)294 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
295 {
296     MessageParcel dataParcel;
297     if (!IsDataAndSizeValid(data, size, dataParcel)) {
298         return;
299     }
300 
301     std::string interfaceName = NetSysGetString(STR_LEN);
302     std::string ipAddr = NetSysGetString(STR_LEN);
303     int32_t prefixLength = NetSysGetData<int32_t>();
304 
305     dataParcel.WriteString(interfaceName);
306     dataParcel.WriteString(ipAddr);
307     dataParcel.WriteInt32(prefixLength);
308     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_ADD_ADDRESS), dataParcel);
309 }
310 
OnRemoteRequestCallBack(uint32_t code,MessageParcel & data)311 int32_t OnRemoteRequestCallBack(uint32_t code, MessageParcel &data)
312 {
313     MessageParcel reply;
314     MessageOption option;
315     NetsysNative::NotifyCallbackTest notifyCallBackTest;
316     int32_t ret = notifyCallBackTest.OnRemoteRequest(code, data, reply, option);
317     return ret;
318 }
319 
OnInterfaceAddressUpdatedFuzzTest(const uint8_t * data,size_t size)320 void OnInterfaceAddressUpdatedFuzzTest(const uint8_t *data, size_t size)
321 {
322     MessageParcel dataParcel;
323     if (!IsDataAndSizeValid(data, size, dataParcel)) {
324         return;
325     }
326 
327     std::string addr = NetSysGetString(STR_LEN);
328     std::string ifName = NetSysGetString(STR_LEN);
329     int32_t flags = NetSysGetData<int32_t>();
330     int32_t scope = NetSysGetData<int32_t>();
331 
332     dataParcel.WriteString(addr);
333     dataParcel.WriteString(ifName);
334     dataParcel.WriteInt32(flags);
335     dataParcel.WriteInt32(scope);
336     OnRemoteRequestCallBack(static_cast<uint32_t>(NetsysNative::NotifyInterfaceCode::ON_INTERFACE_ADDRESS_UPDATED),
337                             dataParcel);
338 }
339 
RegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)340 void RegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
341 {
342     MessageParcel dataParcel;
343     if (!IsDataAndSizeValid(data, size, dataParcel)) {
344         return;
345     }
346 
347     sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) NetsysNative::NotifyCallbackTest();
348     notifyCb->Marshalling(dataParcel);
349     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_REGISTER_NOTIFY_CALLBACK),
350                     dataParcel);
351 }
352 
UnRegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)353 void UnRegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
354 {
355     MessageParcel dataParcel;
356     if (!IsDataAndSizeValid(data, size, dataParcel)) {
357         return;
358     }
359 
360     sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) NetsysNative::NotifyCallbackTest();
361 
362     notifyCb->Marshalling(dataParcel);
363     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UNREGISTER_NOTIFY_CALLBACK),
364                     dataParcel);
365 }
366 
InterfaceSetIffUpFuzzTest(const uint8_t * data,size_t size)367 void InterfaceSetIffUpFuzzTest(const uint8_t *data, size_t size)
368 {
369     MessageParcel dataParcel;
370     if (!IsDataAndSizeValid(data, size, dataParcel)) {
371         return;
372     }
373 
374     std::string ifaceName = NetSysGetString(STR_LEN);
375 
376     if (!dataParcel.WriteString("-L -n")) {
377         return;
378     }
379 
380     dataParcel.WriteString(ifaceName);
381     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IFF_UP), dataParcel);
382 }
383 
GetAddrInfoFuzzTest(const uint8_t * data,size_t size)384 void GetAddrInfoFuzzTest(const uint8_t *data, size_t size)
385 {
386     MessageParcel dataParcel;
387     if (!IsDataAndSizeValid(data, size, dataParcel)) {
388         return;
389     }
390 
391     std::string hostName = NetSysGetString(STR_LEN);
392     std::string serverName = NetSysGetString(STR_LEN);
393     AddrInfo hints;
394     hints.aiFlags = NetSysGetData<uint32_t>();
395     hints.aiFamily = NetSysGetData<uint32_t>();
396     hints.aiSockType = NetSysGetData<uint32_t>();
397     hints.aiProtocol = NetSysGetData<uint32_t>();
398     hints.aiAddrLen = NetSysGetData<uint32_t>();
399 
400     std::string aiCanName = NetSysGetString(STR_LEN);
401     if (memcpy_s(hints.aiCanonName, sizeof(hints.aiCanonName), aiCanName.c_str(), aiCanName.length()) != 0) {
402         return;
403     }
404     uint16_t netId = NetSysGetData<uint16_t>();
405 
406     dataParcel.WriteString(hostName);
407     dataParcel.WriteString(serverName);
408     dataParcel.WriteRawData(&hints, sizeof(AddrInfo));
409     dataParcel.WriteUint16(netId);
410     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ADDR_INFO), dataParcel);
411 }
412 
NetworkAddRouteParcelFuzzTest(const uint8_t * data,size_t size)413 void NetworkAddRouteParcelFuzzTest(const uint8_t *data, size_t size)
414 {
415     MessageParcel dataParcel;
416     if (!IsDataAndSizeValid(data, size, dataParcel)) {
417         return;
418     }
419 
420     int32_t netId = NetSysGetData<int32_t>();
421     NetsysNative::RouteInfoParcel routInfo;
422     routInfo.destination = NetSysGetString(STR_LEN);
423     routInfo.ifName = NetSysGetString(STR_LEN);
424     routInfo.nextHop = NetSysGetString(STR_LEN);
425     routInfo.mtu = NetSysGetData<int32_t>();
426 
427     dataParcel.WriteInt32(netId);
428     dataParcel.WriteString(routInfo.destination);
429     dataParcel.WriteString(routInfo.ifName);
430     dataParcel.WriteString(routInfo.nextHop);
431     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE_PARCEL),
432                     dataParcel);
433 }
434 
NetworkRemoveRouteParcelFuzzTest(const uint8_t * data,size_t size)435 void NetworkRemoveRouteParcelFuzzTest(const uint8_t *data, size_t size)
436 {
437     MessageParcel dataParcel;
438     if (!IsDataAndSizeValid(data, size, dataParcel)) {
439         return;
440     }
441 
442     int32_t netId = NetSysGetData<int32_t>();
443     NetsysNative::RouteInfoParcel routInfo;
444     routInfo.destination = NetSysGetString(STR_LEN);
445     routInfo.ifName = NetSysGetString(STR_LEN);
446     routInfo.nextHop = NetSysGetString(STR_LEN);
447 
448     dataParcel.WriteInt32(netId);
449     dataParcel.WriteString(routInfo.destination);
450     dataParcel.WriteString(routInfo.ifName);
451     dataParcel.WriteString(routInfo.nextHop);
452     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_ROUTE_PARCEL),
453                     dataParcel);
454 }
455 
NetworkSetDefaultFuzzTest(const uint8_t * data,size_t size)456 void NetworkSetDefaultFuzzTest(const uint8_t *data, size_t size)
457 {
458     MessageParcel dataParcel;
459     if (!IsDataAndSizeValid(data, size, dataParcel)) {
460         return;
461     }
462 
463     int32_t netId = NetSysGetData<int32_t>();
464 
465     dataParcel.WriteInt32(netId);
466     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_SET_DEFAULT), dataParcel);
467 }
468 
NetworkGetDefaultFuzzTest(const uint8_t * data,size_t size)469 void NetworkGetDefaultFuzzTest(const uint8_t *data, size_t size)
470 {
471     MessageParcel dataParcel;
472     if (!IsDataAndSizeValid(data, size, dataParcel)) {
473         return;
474     }
475     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_GET_DEFAULT), dataParcel);
476 }
SetDefaultNetWorkFuzzTest(const uint8_t * data,size_t size)477 void SetDefaultNetWorkFuzzTest(const uint8_t *data, size_t size)
478 {
479     MessageParcel dataParcel;
480     if (!IsDataAndSizeValid(data, size, dataParcel)) {
481         return;
482     }
483 
484     int32_t netId = NetSysGetData<int32_t>();
485 
486     dataParcel.WriteInt32(netId);
487     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_SET_DEFAULT), dataParcel);
488 }
489 
IpfwdAddInterfaceForwardFuzzTest(const uint8_t * data,size_t size)490 void IpfwdAddInterfaceForwardFuzzTest(const uint8_t *data, size_t size)
491 {
492     MessageParcel dataParcel;
493     if (!IsDataAndSizeValid(data, size, dataParcel)) {
494         return;
495     }
496 
497     std::string fromIface = NetSysGetString(STR_LEN);
498     std::string toIface = NetSysGetString(STR_LEN);
499 
500     dataParcel.WriteString(fromIface);
501     dataParcel.WriteString(toIface);
502     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_ADD_INTERFACE_FORWARD),
503                     dataParcel);
504 }
505 
IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t * data,size_t size)506 void IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t *data, size_t size)
507 {
508     MessageParcel dataParcel;
509     if (!IsDataAndSizeValid(data, size, dataParcel)) {
510         return;
511     }
512 
513     std::string fromIface = NetSysGetString(STR_LEN);
514     std::string toIface = NetSysGetString(STR_LEN);
515 
516     dataParcel.WriteString(fromIface);
517     dataParcel.WriteString(toIface);
518     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_REMOVE_INTERFACE_FORWARD),
519                     dataParcel);
520 }
521 
InterfaceSetIpAddressFuzzTest(const uint8_t * data,size_t size)522 void InterfaceSetIpAddressFuzzTest(const uint8_t *data, size_t size)
523 {
524     MessageParcel dataParcel;
525     if (!IsDataAndSizeValid(data, size, dataParcel)) {
526         return;
527     }
528 
529     std::string ifaceName = NetSysGetString(STR_LEN);
530     std::string ipAddress = NetSysGetString(STR_LEN);
531 
532     dataParcel.WriteString(ifaceName);
533     dataParcel.WriteString(ipAddress);
534     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IP_ADDRESS),
535                     dataParcel);
536 }
537 
FirewallSetUidsAllowedListChainFuzzTest(const uint8_t * data,size_t size)538 void FirewallSetUidsAllowedListChainFuzzTest(const uint8_t *data, size_t size)
539 {
540     MessageParcel dataParcel;
541     if (!IsDataAndSizeValid(data, size, dataParcel)) {
542         return;
543     }
544 
545     auto chain = NetSysGetData<uint32_t>();
546     auto uidSize = static_cast<uint32_t>(NetSysGetData<uint8_t>());
547 
548     dataParcel.WriteUint32(chain);
549     dataParcel.WriteUint32(uidSize);
550     for (uint32_t index = 0; index < uidSize; index++) {
551         dataParcel.WriteUint32(NetSysGetData<uint32_t>());
552     }
553     OnRemoteRequest(
554         static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_ALLOWED_LIST_CHAIN),
555         dataParcel);
556 }
557 
FirewallSetUidsDeniedListChainFuzzTest(const uint8_t * data,size_t size)558 void FirewallSetUidsDeniedListChainFuzzTest(const uint8_t *data, size_t size)
559 {
560     MessageParcel dataParcel;
561     if (!IsDataAndSizeValid(data, size, dataParcel)) {
562         return;
563     }
564 
565     auto chain = NetSysGetData<uint32_t>();
566     auto uidSize = static_cast<uint32_t>(NetSysGetData<uint8_t>());
567 
568     dataParcel.WriteUint32(chain);
569     dataParcel.WriteUint32(uidSize);
570     for (uint32_t index = 0; index < uidSize; index++) {
571         dataParcel.WriteUint32(NetSysGetData<uint32_t>());
572     }
573     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_DENIED_LIST_CHAIN),
574                     dataParcel);
575 }
576 
FirewallSetUidRuleFuzzTest(const uint8_t * data,size_t size)577 void FirewallSetUidRuleFuzzTest(const uint8_t *data, size_t size)
578 {
579     MessageParcel dataParcel;
580     if (!IsDataAndSizeValid(data, size, dataParcel)) {
581         return;
582     }
583 
584     int32_t chain = NetSysGetData<int32_t>();
585     int32_t firewallRule = NetSysGetData<int32_t>();
586 
587     dataParcel.WriteInt32(chain);
588     uint32_t vectorLength = NetSysGetData<uint32_t>() % VECTOR_MAX_SIZE;
589     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
590     for (uint32_t i = 0; i <= vectorLength; i++) {
591         dataParcel.WriteInt32(NetSysGetData<uint32_t>());
592     }
593 
594     dataParcel.WriteInt32(firewallRule);
595 
596     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_RULE), dataParcel);
597 }
SetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)598 void SetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
599 {
600     MessageParcel dataParcel;
601     if (!IsDataAndSizeValid(data, size, dataParcel)) {
602         return;
603     }
604 
605     OHOS::nmd::InterfaceConfigurationParcel cfg;
606     cfg.ifName = NetSysGetString(STR_LEN);
607     cfg.hwAddr = NetSysGetString(STR_LEN);
608     cfg.ipv4Addr = NetSysGetString(STR_LEN);
609     cfg.prefixLength = NetSysGetData<int32_t>();
610 
611     dataParcel.WriteString(cfg.ifName);
612     dataParcel.WriteString(cfg.hwAddr);
613     dataParcel.WriteString(cfg.ipv4Addr);
614     dataParcel.WriteInt32(cfg.prefixLength);
615     uint32_t vectorLength = NetSysGetData<uint32_t>() % VECTOR_MAX_SIZE;
616     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
617     for (uint32_t i = 0; i <= vectorLength; i++) {
618         dataParcel.WriteString(NetSysGetString(STR_LEN));
619     }
620 
621     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_CONFIG), dataParcel);
622 }
623 
NetworkClearDefaultFuzzTest(const uint8_t * data,size_t size)624 void NetworkClearDefaultFuzzTest(const uint8_t *data, size_t size)
625 {
626     MessageParcel dataParcel;
627     if (!IsDataAndSizeValid(data, size, dataParcel)) {
628         return;
629     }
630     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CLEAR_DEFAULT), dataParcel);
631 }
632 
GetProcSysNetFuzzTest(const uint8_t * data,size_t size)633 void GetProcSysNetFuzzTest(const uint8_t *data, size_t size)
634 {
635     MessageParcel dataParcel;
636     if (!IsDataAndSizeValid(data, size, dataParcel)) {
637         return;
638     }
639 
640     int32_t family = NetSysGetData<int32_t>();
641     int32_t which = NetSysGetData<int32_t>();
642     std::string ifname = NetSysGetString(STR_LEN);
643     std::string parameter = NetSysGetString(STR_LEN);
644 
645     dataParcel.WriteInt32(family);
646     dataParcel.WriteInt32(which);
647     dataParcel.WriteString(ifname);
648     dataParcel.WriteString(parameter);
649     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_PROC_SYS_NET), dataParcel);
650 }
651 
SetProcSysNetFuzzTest(const uint8_t * data,size_t size)652 void SetProcSysNetFuzzTest(const uint8_t *data, size_t size)
653 {
654     MessageParcel dataParcel;
655     if (!IsDataAndSizeValid(data, size, dataParcel)) {
656         return;
657     }
658 
659     int32_t family = NetSysGetData<int32_t>();
660     int32_t which = NetSysGetData<int32_t>();
661     std::string ifname = NetSysGetString(STR_LEN);
662     std::string parameter = NetSysGetString(STR_LEN);
663     std::string value = NetSysGetString(STR_LEN);
664 
665     dataParcel.WriteInt32(family);
666     dataParcel.WriteInt32(which);
667     dataParcel.WriteString(ifname);
668     dataParcel.WriteString(parameter);
669     dataParcel.WriteString(value);
670     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_PROC_SYS_NET), dataParcel);
671 }
672 
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)673 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
674 {
675     MessageParcel dataParcel;
676     if (!IsDataAndSizeValid(data, size, dataParcel)) {
677         return;
678     }
679 
680     uint32_t uid = NetSysGetData<uint32_t>();
681     int8_t allow = NetSysGetData<int8_t>();
682 
683     dataParcel.WriteUint32(uid);
684     dataParcel.WriteInt8(allow);
685     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_INTERNET_PERMISSION),
686                     dataParcel);
687 }
688 
GetFwmarkForNetworkFuzzTest(const uint8_t * data,size_t size)689 void GetFwmarkForNetworkFuzzTest(const uint8_t *data, size_t size)
690 {
691     MessageParcel dataParcel;
692     if (!IsDataAndSizeValid(data, size, dataParcel)) {
693         return;
694     }
695 
696     int32_t netId = NetSysGetData<int32_t>();
697     NetsysNative::MarkMaskParcel markParcl;
698     markParcl.mark = NetSysGetData<int32_t>();
699     markParcl.mask = NetSysGetData<int32_t>();
700 
701     dataParcel.WriteInt32(netId);
702     dataParcel.WriteInt32(markParcl.mark);
703     dataParcel.WriteInt32(markParcl.mask);
704     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_FWMARK_FOR_NETWORK),
705                     dataParcel);
706 }
707 
IpEnableForwardingFuzzTest(const uint8_t * data,size_t size)708 void IpEnableForwardingFuzzTest(const uint8_t *data, size_t size)
709 {
710     MessageParcel dataParcel;
711     if (!IsDataAndSizeValid(data, size, dataParcel)) {
712         return;
713     }
714 
715     std::string requestor = NetSysGetString(STR_LEN);
716 
717     dataParcel.WriteString(requestor);
718     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPENABLE_FORWARDING), dataParcel);
719 }
720 
IpDisableForwardingFuzzTest(const uint8_t * data,size_t size)721 void IpDisableForwardingFuzzTest(const uint8_t *data, size_t size)
722 {
723     MessageParcel dataParcel;
724     if (!IsDataAndSizeValid(data, size, dataParcel)) {
725         return;
726     }
727 
728     std::string requestor = NetSysGetString(STR_LEN);
729 
730     dataParcel.WriteString(requestor);
731     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPDISABLE_FORWARDING), dataParcel);
732 }
733 
EnableNatFuzzTest(const uint8_t * data,size_t size)734 void EnableNatFuzzTest(const uint8_t *data, size_t size)
735 {
736     MessageParcel dataParcel;
737     if (!IsDataAndSizeValid(data, size, dataParcel)) {
738         return;
739     }
740 
741     std::string downstreamIface = NetSysGetString(STR_LEN);
742     std::string upstreamIface = NetSysGetString(STR_LEN);
743 
744     dataParcel.WriteString(downstreamIface);
745     dataParcel.WriteString(upstreamIface);
746     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_ENABLE_NAT), dataParcel);
747 }
748 
DisableNatFuzzTest(const uint8_t * data,size_t size)749 void DisableNatFuzzTest(const uint8_t *data, size_t size)
750 {
751     MessageParcel dataParcel;
752     if (!IsDataAndSizeValid(data, size, dataParcel)) {
753         return;
754     }
755 
756     std::string downstreamIface = NetSysGetString(STR_LEN);
757     std::string upstreamIface = NetSysGetString(STR_LEN);
758 
759     dataParcel.WriteString(downstreamIface);
760     dataParcel.WriteString(upstreamIface);
761     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DISABLE_NAT), dataParcel);
762 }
763 
BandwidthEnableDataSaverFuzzTest(const uint8_t * data,size_t size)764 void BandwidthEnableDataSaverFuzzTest(const uint8_t *data, size_t size)
765 {
766     MessageParcel dataParcel;
767     if (!IsDataAndSizeValid(data, size, dataParcel)) {
768         return;
769     }
770 
771     bool enable = NetSysGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
772 
773     dataParcel.WriteBool(enable);
774     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ENABLE_DATA_SAVER),
775                     dataParcel);
776 }
777 
BandwidthSetIfaceQuotaFuzzTest(const uint8_t * data,size_t size)778 void BandwidthSetIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
779 {
780     MessageParcel dataParcel;
781     if (!IsDataAndSizeValid(data, size, dataParcel)) {
782         return;
783     }
784 
785     int64_t bytes = NetSysGetData<int64_t>();
786     std::string ifName = NetSysGetString(STR_LEN);
787 
788     dataParcel.WriteString(ifName);
789     dataParcel.WriteInt64(bytes);
790     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_SET_IFACE_QUOTA),
791                     dataParcel);
792 }
793 
BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t * data,size_t size)794 void BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
795 {
796     MessageParcel dataParcel;
797     if (!IsDataAndSizeValid(data, size, dataParcel)) {
798         return;
799     }
800 
801     std::string ifName = NetSysGetString(STR_LEN);
802 
803     dataParcel.WriteString(ifName);
804     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_IFACE_QUOTA),
805                     dataParcel);
806 }
807 
BandwidthAddDeniedListFuzzTest(const uint8_t * data,size_t size)808 void BandwidthAddDeniedListFuzzTest(const uint8_t *data, size_t size)
809 {
810     MessageParcel dataParcel;
811     if (!IsDataAndSizeValid(data, size, dataParcel)) {
812         return;
813     }
814 
815     uint32_t uid = NetSysGetData<uint32_t>();
816 
817     dataParcel.WriteInt32(uid);
818     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_DENIED_LIST),
819                     dataParcel);
820 }
821 
BandwidthRemoveDeniedListFuzzTest(const uint8_t * data,size_t size)822 void BandwidthRemoveDeniedListFuzzTest(const uint8_t *data, size_t size)
823 {
824     MessageParcel dataParcel;
825     if (!IsDataAndSizeValid(data, size, dataParcel)) {
826         return;
827     }
828 
829     uint32_t uid = NetSysGetData<uint32_t>();
830 
831     dataParcel.WriteInt32(uid);
832     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_DENIED_LIST),
833                     dataParcel);
834 }
835 
BandwidthAddAllowedListFuzzTest(const uint8_t * data,size_t size)836 void BandwidthAddAllowedListFuzzTest(const uint8_t *data, size_t size)
837 {
838     MessageParcel dataParcel;
839     if (!IsDataAndSizeValid(data, size, dataParcel)) {
840         return;
841     }
842 
843     uint32_t uid = NetSysGetData<uint32_t>();
844 
845     dataParcel.WriteInt32(uid);
846     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_ALLOWED_LIST),
847                     dataParcel);
848 }
849 
BandwidthRemoveAllowedListFuzzTest(const uint8_t * data,size_t size)850 void BandwidthRemoveAllowedListFuzzTest(const uint8_t *data, size_t size)
851 {
852     MessageParcel dataParcel;
853     if (!IsDataAndSizeValid(data, size, dataParcel)) {
854         return;
855     }
856 
857     uint32_t uid = NetSysGetData<uint32_t>();
858 
859     dataParcel.WriteInt32(uid);
860     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_ALLOWED_LIST),
861                     dataParcel);
862 }
863 
FirewallEnableChainFuzzTest(const uint8_t * data,size_t size)864 void FirewallEnableChainFuzzTest(const uint8_t *data, size_t size)
865 {
866     MessageParcel dataParcel;
867     if (!IsDataAndSizeValid(data, size, dataParcel)) {
868         return;
869     }
870 
871     uint32_t chain = NetSysGetData<uint32_t>();
872     bool enable = NetSysGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
873 
874     dataParcel.WriteInt32(chain);
875     dataParcel.WriteBool(enable);
876     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_ENABLE_CHAIN), dataParcel);
877 }
878 
GetNetworkSharingTrafficFuzzTest(const uint8_t * data,size_t size)879 void GetNetworkSharingTrafficFuzzTest(const uint8_t *data, size_t size)
880 {
881     MessageParcel dataParcel;
882     if (!IsDataAndSizeValid(data, size, dataParcel)) {
883         return;
884     }
885 
886     std::string downIface = NetSysGetString(STR_LEN);
887     std::string upIface = NetSysGetString(STR_LEN);
888 
889     dataParcel.WriteString(downIface);
890     dataParcel.WriteString(upIface);
891     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_SHARING_NETWORK_TRAFFIC),
892                     dataParcel);
893 }
894 
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)895 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
896 {
897     MessageParcel dataParcel;
898     if (!IsDataAndSizeValid(data, size, dataParcel)) {
899         return;
900     }
901 
902     std::string interfaceName = NetSysGetString(STR_LEN);
903     std::string ipAddr = NetSysGetString(STR_LEN);
904     int32_t prefixLength = NetSysGetData<int32_t>();
905 
906     dataParcel.WriteString(interfaceName);
907     dataParcel.WriteString(ipAddr);
908     dataParcel.WriteInt32(prefixLength);
909     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_DEL_ADDRESS), dataParcel);
910 }
911 
SetResolverConfigFuzzTest(const uint8_t * data,size_t size)912 void SetResolverConfigFuzzTest(const uint8_t *data, size_t size)
913 {
914     MessageParcel dataParcel;
915     if (!IsDataAndSizeValid(data, size, dataParcel)) {
916         return;
917     }
918 
919     uint16_t netId = NetSysGetData<uint16_t>();
920     uint16_t baseTimeoutMsec = NetSysGetData<uint16_t>();
921     uint8_t retryCount = NetSysGetData<uint8_t>();
922 
923     dataParcel.WriteUint16(netId);
924     dataParcel.WriteUint16(baseTimeoutMsec);
925     dataParcel.WriteUint8(retryCount);
926 
927     uint32_t vectorLength = NetSysGetData<uint32_t>() % VECTOR_MAX_SIZE;
928     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
929     for (uint32_t i = 0; i <= vectorLength; i++) {
930         dataParcel.WriteString(NetSysGetString(STR_LEN));
931     }
932 
933     uint32_t vectorLength2 = NetSysGetData<uint32_t>() % VECTOR_MAX_SIZE;
934     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength2));
935     for (uint32_t i = 0; i <= vectorLength2; i++) {
936         dataParcel.WriteString(NetSysGetString(STR_LEN));
937     }
938     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_RESOLVER_CONFIG), dataParcel);
939 }
940 
GetResolverConfigFuzzTest(const uint8_t * data,size_t size)941 void GetResolverConfigFuzzTest(const uint8_t *data, size_t size)
942 {
943     MessageParcel dataParcel;
944     if (!IsDataAndSizeValid(data, size, dataParcel)) {
945         return;
946     }
947 
948     uint16_t netId = NetSysGetData<uint16_t>();
949 
950     dataParcel.WriteUint16(netId);
951     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_RESOLVER_CONFIG), dataParcel);
952 }
953 
CreateNetworkCacheFuzzTest(const uint8_t * data,size_t size)954 void CreateNetworkCacheFuzzTest(const uint8_t *data, size_t size)
955 {
956     MessageParcel dataParcel;
957     if (!IsDataAndSizeValid(data, size, dataParcel)) {
958         return;
959     }
960 
961     uint16_t netId = NetSysGetData<uint16_t>();
962 
963     dataParcel.WriteUint16(netId);
964     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_CREATE_NETWORK_CACHE), dataParcel);
965 }
966 
DestroyNetworkCacheFuzzTest(const uint8_t * data,size_t size)967 void DestroyNetworkCacheFuzzTest(const uint8_t *data, size_t size)
968 {
969     MessageParcel dataParcel;
970     if (!IsDataAndSizeValid(data, size, dataParcel)) {
971         return;
972     }
973 
974     uint16_t netId = NetSysGetData<uint16_t>();
975 
976     dataParcel.WriteUint16(netId);
977     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DESTROY_NETWORK_CACHE), dataParcel);
978 }
979 
InterfaceGetListFuzzTest(const uint8_t * data,size_t size)980 void InterfaceGetListFuzzTest(const uint8_t *data, size_t size)
981 {
982     MessageParcel dataParcel;
983     if (!IsDataAndSizeValid(data, size, dataParcel)) {
984         return;
985     }
986     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_LIST), dataParcel);
987 }
988 
ShareDnsSetFuzzTest(const uint8_t * data,size_t size)989 void ShareDnsSetFuzzTest(const uint8_t *data, size_t size)
990 {
991     MessageParcel dataParcel;
992     if (!IsDataAndSizeValid(data, size, dataParcel)) {
993         return;
994     }
995     uint16_t netId = NetSysGetData<uint16_t>();
996     dataParcel.WriteUint16(netId);
997     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_TETHER_DNS_SET), dataParcel);
998 }
999 
StartDnsProxyListenFuzzTest(const uint8_t * data,size_t size)1000 void StartDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
1001 {
1002     MessageParcel dataParcel;
1003     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1004         return;
1005     }
1006     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DNS_PROXY_LISTEN),
1007                     dataParcel);
1008 }
1009 
StopDnsProxyListenFuzzTest(const uint8_t * data,size_t size)1010 void StopDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
1011 {
1012     MessageParcel dataParcel;
1013     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1014         return;
1015     }
1016     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DNS_PROXY_LISTEN), dataParcel);
1017 }
1018 
StartDhcpClientFuzzTest(const uint8_t * data,size_t size)1019 void StartDhcpClientFuzzTest(const uint8_t *data, size_t size)
1020 {
1021     MessageParcel dataParcel;
1022     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1023         return;
1024     }
1025     std::string iface = NetSysGetString(STR_LEN);
1026     bool bIpv6 = NetSysGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1027     dataParcel.WriteString(iface);
1028     dataParcel.WriteBool(bIpv6);
1029     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_CLIENT), dataParcel);
1030 }
1031 
StopDhcpClientFuzzTest(const uint8_t * data,size_t size)1032 void StopDhcpClientFuzzTest(const uint8_t *data, size_t size)
1033 {
1034     MessageParcel dataParcel;
1035     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1036         return;
1037     }
1038     std::string iface = NetSysGetString(STR_LEN);
1039     bool bIpv6 = NetSysGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1040 
1041     dataParcel.WriteString(iface);
1042     dataParcel.WriteBool(bIpv6);
1043     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_CLIENT), dataParcel);
1044 }
1045 
StartDhcpServiceFuzzTest(const uint8_t * data,size_t size)1046 void StartDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1047 {
1048     MessageParcel dataParcel;
1049     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1050         return;
1051     }
1052     std::string iface = NetSysGetString(STR_LEN);
1053     std::string ipv4addr = NetSysGetString(STR_LEN);
1054     dataParcel.WriteString(iface);
1055     dataParcel.WriteString(ipv4addr);
1056     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_SERVICE), dataParcel);
1057 }
1058 
StopDhcpServiceFuzzTest(const uint8_t * data,size_t size)1059 void StopDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1060 {
1061     MessageParcel dataParcel;
1062     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1063         return;
1064     }
1065     std::string iface = NetSysGetString(STR_LEN);
1066     dataParcel.WriteString(iface);
1067     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_SERVICE), dataParcel);
1068 }
1069 
GetTotalStatsFuzzTest(const uint8_t * data,size_t size)1070 void GetTotalStatsFuzzTest(const uint8_t *data, size_t size)
1071 {
1072     MessageParcel dataParcel;
1073     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1074         return;
1075     }
1076 
1077     uint32_t type = NetSysGetData<uint32_t>();
1078     dataParcel.WriteUint32(type);
1079     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_TOTAL_STATS), dataParcel);
1080 }
1081 
GetUidStatsFuzzTest(const uint8_t * data,size_t size)1082 void GetUidStatsFuzzTest(const uint8_t *data, size_t size)
1083 {
1084     MessageParcel dataParcel;
1085     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1086         return;
1087     }
1088     uint32_t type = NetSysGetData<uint32_t>();
1089     uint32_t uid = NetSysGetData<uint32_t>();
1090 
1091     dataParcel.WriteUint32(type);
1092     dataParcel.WriteUint32(uid);
1093     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_UID_STATS), dataParcel);
1094 }
1095 
GetIfaceStatsFuzzTest(const uint8_t * data,size_t size)1096 void GetIfaceStatsFuzzTest(const uint8_t *data, size_t size)
1097 {
1098     MessageParcel dataParcel;
1099     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1100         return;
1101     }
1102     uint32_t type = NetSysGetData<uint32_t>();
1103     std::string iface = NetSysGetString(STR_LEN);
1104 
1105     dataParcel.WriteUint32(type);
1106     dataParcel.WriteString(iface);
1107     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_IFACE_STATS), dataParcel);
1108 }
1109 
GetAllStatsInfoFuzzTest(const uint8_t * data,size_t size)1110 void GetAllStatsInfoFuzzTest(const uint8_t *data, size_t size)
1111 {
1112     MessageParcel dataParcel;
1113     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1114         return;
1115     }
1116 
1117     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ALL_STATS_INFO), dataParcel);
1118 }
1119 
SetIptablesCommandForResFuzzTest(const uint8_t * data,size_t size)1120 void SetIptablesCommandForResFuzzTest(const uint8_t *data, size_t size)
1121 {
1122     MessageParcel dataParcel;
1123     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1124         return;
1125     }
1126     if (!dataParcel.WriteString("-L -n")) {
1127         return;
1128     }
1129 
1130     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_IPTABLES_CMD_FOR_RES),
1131                     dataParcel);
1132 }
1133 
NetworkCreateVirtualFuzzTest(const uint8_t * data,size_t size)1134 void NetworkCreateVirtualFuzzTest(const uint8_t *data, size_t size)
1135 {
1136     MessageParcel dataParcel;
1137     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1138         return;
1139     }
1140 
1141     int32_t netId = NetSysGetData<int32_t>();
1142     bool hasDns = NetSysGetData<bool>();
1143 
1144     dataParcel.WriteInt32(netId);
1145     dataParcel.WriteBool(hasDns);
1146 
1147     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_VIRTUAL),
1148                     dataParcel);
1149 }
1150 
NetworkAddUidsFuzzTest(const uint8_t * data,size_t size)1151 void NetworkAddUidsFuzzTest(const uint8_t *data, size_t size)
1152 {
1153     MessageParcel dataParcel;
1154     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1155         return;
1156     }
1157 
1158     int32_t netId = NetSysGetData<int32_t>();
1159     std::vector<UidRange> uidRanges;
1160     UidRange uid;
1161     int32_t rangesSize = NetSysGetData<int32_t>() % VECTOR_MAX_SIZE;
1162     for (int i = 0; i < rangesSize; i++) {
1163         uidRanges.emplace_back(uid);
1164     }
1165 
1166     dataParcel.WriteInt32(netId);
1167     dataParcel.WriteInt32(rangesSize);
1168     for (auto iter : uidRanges) {
1169         iter.Marshalling(dataParcel);
1170     }
1171 
1172     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_UIDS), dataParcel);
1173 }
1174 
NetworkDelUidsFuzzTest(const uint8_t * data,size_t size)1175 void NetworkDelUidsFuzzTest(const uint8_t *data, size_t size)
1176 {
1177     MessageParcel dataParcel;
1178     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1179         return;
1180     }
1181 
1182     int32_t netId = NetSysGetData<int32_t>();
1183     std::vector<UidRange> uidRanges;
1184     UidRange uid;
1185     int32_t rangesSize = NetSysGetData<int32_t>() % VECTOR_MAX_SIZE;
1186     for (int i = 0; i < rangesSize; i++) {
1187         uidRanges.emplace_back(uid);
1188     }
1189 
1190     dataParcel.WriteInt32(netId);
1191     dataParcel.WriteInt32(rangesSize);
1192     for (auto iter : uidRanges) {
1193         iter.Marshalling(dataParcel);
1194     }
1195 
1196     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DEL_UIDS), dataParcel);
1197 }
1198 
GetCookieStatsFuzzTest(const uint8_t * data,size_t size)1199 void GetCookieStatsFuzzTest(const uint8_t *data, size_t size)
1200 {
1201     MessageParcel dataParcel;
1202     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1203         return;
1204     }
1205     uint32_t type = NetSysGetData<uint32_t>();
1206     uint64_t cookie = NetSysGetData<uint64_t>();
1207 
1208     dataParcel.WriteUint32(type);
1209     dataParcel.WriteUint64(cookie);
1210     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_COOKIE_STATS), dataParcel);
1211 }
1212 
CmdCreateNetworkCacheFuzzTest(const uint8_t * data,size_t size)1213 void CmdCreateNetworkCacheFuzzTest(const uint8_t *data, size_t size)
1214 {
1215     MessageParcel dataParcel;
1216     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1217         return;
1218     }
1219     uint16_t netId = NetSysGetData<uint16_t>();
1220     dataParcel.WriteUint16(netId);
1221 
1222     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_CREATE_NETWORK_CACHE), dataParcel);
1223 }
1224 
CmdGetTotalStatsFuzzTest(const uint8_t * data,size_t size)1225 void CmdGetTotalStatsFuzzTest(const uint8_t *data, size_t size)
1226 {
1227     MessageParcel dataParcel;
1228     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1229         return;
1230     }
1231     uint8_t type = NetSysGetData<uint8_t>();
1232     dataParcel.WriteUint8(type);
1233     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_TOTAL_STATS), dataParcel);
1234 }
1235 
CmdSetTcpBufferSizesFuzzTest(const uint8_t * data,size_t size)1236 void CmdSetTcpBufferSizesFuzzTest(const uint8_t *data, size_t size)
1237 {
1238     MessageParcel dataParcel;
1239     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1240         return;
1241     }
1242     std::string tcpBufferSizes = NetSysGetString(STR_LEN);
1243     dataParcel.WriteString(tcpBufferSizes);
1244     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_TCP_BUFFER_SIZES), dataParcel);
1245 }
1246 
CmdGetAllStatsInfoFuzzTest(const uint8_t * data,size_t size)1247 void CmdGetAllStatsInfoFuzzTest(const uint8_t *data, size_t size)
1248 {
1249     MessageParcel dataParcel;
1250     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1251         return;
1252     }
1253     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ALL_STATS_INFO), dataParcel);
1254 }
1255 
CmdSetIptablesCommandForResFuzzTest(const uint8_t * data,size_t size)1256 void CmdSetIptablesCommandForResFuzzTest(const uint8_t *data, size_t size)
1257 {
1258     MessageParcel dataParcel;
1259     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1260         return;
1261     }
1262     std::string cmd = NetSysGetString(STR_LEN);
1263     dataParcel.WriteString(cmd);
1264     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_IPTABLES_CMD_FOR_RES),
1265                     dataParcel);
1266 }
1267 
CmdAddStaticArpFuzzTest(const uint8_t * data,size_t size)1268 void CmdAddStaticArpFuzzTest(const uint8_t *data, size_t size)
1269 {
1270     MessageParcel dataParcel;
1271     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1272         return;
1273     }
1274     std::string ipAddr = NetSysGetString(STR_LEN);
1275     dataParcel.WriteString(ipAddr);
1276     std::string macAddr = NetSysGetString(STR_LEN);
1277     dataParcel.WriteString(macAddr);
1278     std::string ifName = NetSysGetString(STR_LEN);
1279     dataParcel.WriteString(ifName);
1280     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_ADD_STATIC_ARP), dataParcel);
1281 }
1282 
CmdDelStaticArpFuzzTest(const uint8_t * data,size_t size)1283 void CmdDelStaticArpFuzzTest(const uint8_t *data, size_t size)
1284 {
1285     MessageParcel dataParcel;
1286     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1287         return;
1288     }
1289     std::string ifName = NetSysGetString(STR_LEN);
1290     std::string macAddr = NetSysGetString(STR_LEN);
1291     std::string ipAddr = NetSysGetString(STR_LEN);
1292     dataParcel.WriteString(ipAddr);
1293     dataParcel.WriteString(macAddr);
1294     dataParcel.WriteString(ifName);
1295     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DEL_STATIC_ARP), dataParcel);
1296 }
1297 
CmdRegisterDnsResultListenerFuzzTest(const uint8_t * data,size_t size)1298 void CmdRegisterDnsResultListenerFuzzTest(const uint8_t *data, size_t size)
1299 {
1300     MessageParcel dataParcel;
1301     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1302         return;
1303     }
1304     sptr<NetsysNative::INetDnsResultCallback> callback = new (std::nothrow) NetDnsResultCallbackFuzzTest();
1305     if (!dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
1306         return;
1307     }
1308     uint32_t timeStep = NetSysGetData<uint32_t>();
1309     dataParcel.WriteUint32(timeStep);
1310     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_REGISTER_DNS_RESULT_LISTENER),
1311                     dataParcel);
1312 }
1313 
CmdUnregisterDnsResultListenerFuzzTest(const uint8_t * data,size_t size)1314 void CmdUnregisterDnsResultListenerFuzzTest(const uint8_t *data, size_t size)
1315 {
1316     MessageParcel dataParcel;
1317     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1318         return;
1319     }
1320     sptr<NetsysNative::INetDnsResultCallback> callback = new (std::nothrow) NetDnsResultCallbackFuzzTest();
1321     if (!dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
1322         return;
1323     }
1324     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UNREGISTER_DNS_RESULT_LISTENER),
1325                     dataParcel);
1326 }
1327 
CmdRegisterDnsHealthListenerFuzzTest(const uint8_t * data,size_t size)1328 void CmdRegisterDnsHealthListenerFuzzTest(const uint8_t *data, size_t size)
1329 {
1330     MessageParcel dataParcel;
1331     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1332         return;
1333     }
1334     sptr<NetsysNative::INetDnsHealthCallback> callback = new (std::nothrow) TestNetDnsHealthCallbackFuzzTest();
1335     if (!dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
1336         return;
1337     }
1338     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_REGISTER_DNS_HEALTH_LISTENER),
1339                     dataParcel);
1340 }
1341 
CmdUnregisterDnsHealthListenerFuzzTest(const uint8_t * data,size_t size)1342 void CmdUnregisterDnsHealthListenerFuzzTest(const uint8_t *data, size_t size)
1343 {
1344     MessageParcel dataParcel;
1345     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1346         return;
1347     }
1348     sptr<NetsysNative::INetDnsHealthCallback> callback = new (std::nothrow) TestNetDnsHealthCallbackFuzzTest();
1349     if (!dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr())) {
1350         return;
1351     }
1352     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UNREGISTER_DNS_HEALTH_LISTENER),
1353                     dataParcel);
1354 }
1355 
CmdGetNetworkSharingTypeFuzzTest(const uint8_t * data,size_t size)1356 void CmdGetNetworkSharingTypeFuzzTest(const uint8_t *data, size_t size)
1357 {
1358     MessageParcel dataParcel;
1359     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1360         return;
1361     }
1362     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_NETWORK_SHARING_TYPE),
1363                     dataParcel);
1364 }
1365 
CmdUpdateNetworkSharingTypeFuzzTest(const uint8_t * data,size_t size)1366 void CmdUpdateNetworkSharingTypeFuzzTest(const uint8_t *data, size_t size)
1367 {
1368     MessageParcel dataParcel;
1369     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1370         return;
1371     }
1372     uint32_t type = NetSysGetData<uint32_t>();
1373     bool isOpen = NetSysGetData<bool>();
1374     dataParcel.WriteUint32(type);
1375     dataParcel.WriteBool(isOpen);
1376     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UPDATE_NETWORK_SHARING_TYPE),
1377                     dataParcel);
1378 }
1379 
CmdSetNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)1380 void CmdSetNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
1381 {
1382     MessageParcel dataParcel;
1383     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1384         return;
1385     }
1386     NetworkAccessPolicy netAccessPolicy;
1387     uint32_t uid = NetSysGetData<uint32_t>();
1388     netAccessPolicy.wifiAllow = NetSysGetData<bool>();
1389     netAccessPolicy.cellularAllow = NetSysGetData<bool>();
1390     bool reconfirmFlag = NetSysGetData<bool>();
1391     bool isBroker = NetSysGetData<bool>();
1392 
1393     dataParcel.WriteUint32(uid);
1394     dataParcel.WriteUint8(netAccessPolicy.wifiAllow);
1395     dataParcel.WriteUint8(netAccessPolicy.cellularAllow);
1396     dataParcel.WriteBool(reconfirmFlag);
1397     dataParcel.WriteBool(isBroker);
1398     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_NETWORK_ACCESS_POLICY),
1399                     dataParcel);
1400 }
1401 
CmdDeleteNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)1402 void CmdDeleteNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
1403 {
1404     MessageParcel dataParcel;
1405     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1406         return;
1407     }
1408 
1409     uint32_t uid = NetSysGetData<uint32_t>();
1410     dataParcel.WriteUint32(uid);
1411     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DEL_NETWORK_ACCESS_POLICY),
1412                     dataParcel);
1413 }
1414 
CmdNotifyNetBearerTypeChangeFuzzTest(const uint8_t * data,size_t size)1415 void CmdNotifyNetBearerTypeChangeFuzzTest(const uint8_t *data, size_t size)
1416 {
1417     MessageParcel dataParcel;
1418     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1419         return;
1420     }
1421 
1422     uint32_t rangesSize = NetSysGetData<uint32_t>();
1423     uint32_t bearerType = NetSysGetData<uint32_t>();
1424 
1425     std::set<uint32_t> bearerTypes;
1426     dataParcel.WriteUint32(rangesSize);
1427     for (uint32_t i = 0; i < rangesSize; i++) {
1428         bearerTypes.insert(static_cast<uint32_t>(bearerType));
1429     }
1430 
1431     for (auto iter : bearerTypes) {
1432         dataParcel.WriteUint32(iter);
1433     }
1434 
1435     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NOTIFY_NETWORK_BEARER_TYPE_CHANGE),
1436                     dataParcel);
1437 }
1438 
LLVMFuzzerTestOneInputNew(const uint8_t * data,size_t size)1439 void LLVMFuzzerTestOneInputNew(const uint8_t *data, size_t size)
1440 {
1441     OHOS::NetManagerStandard::RegisterNotifyCallbackFuzzTest(data, size);
1442     OHOS::NetManagerStandard::UnRegisterNotifyCallbackFuzzTest(data, size);
1443     OHOS::NetManagerStandard::InterfaceSetIffUpFuzzTest(data, size);
1444     OHOS::NetManagerStandard::GetAddrInfoFuzzTest(data, size);
1445     OHOS::NetManagerStandard::NetworkAddRouteParcelFuzzTest(data, size);
1446     OHOS::NetManagerStandard::NetworkSetDefaultFuzzTest(data, size);
1447     OHOS::NetManagerStandard::NetworkGetDefaultFuzzTest(data, size);
1448     OHOS::NetManagerStandard::NetworkClearDefaultFuzzTest(data, size);
1449     OHOS::NetManagerStandard::GetProcSysNetFuzzTest(data, size);
1450     OHOS::NetManagerStandard::SetProcSysNetFuzzTest(data, size);
1451     OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1452     OHOS::NetManagerStandard::GetFwmarkForNetworkFuzzTest(data, size);
1453     OHOS::NetManagerStandard::IpEnableForwardingFuzzTest(data, size);
1454     OHOS::NetManagerStandard::IpDisableForwardingFuzzTest(data, size);
1455     OHOS::NetManagerStandard::EnableNatFuzzTest(data, size);
1456     OHOS::NetManagerStandard::DisableNatFuzzTest(data, size);
1457     OHOS::NetManagerStandard::BandwidthEnableDataSaverFuzzTest(data, size);
1458     OHOS::NetManagerStandard::BandwidthSetIfaceQuotaFuzzTest(data, size);
1459     OHOS::NetManagerStandard::BandwidthRemoveIfaceQuotaFuzzTest(data, size);
1460     OHOS::NetManagerStandard::BandwidthAddDeniedListFuzzTest(data, size);
1461     OHOS::NetManagerStandard::BandwidthRemoveDeniedListFuzzTest(data, size);
1462     OHOS::NetManagerStandard::BandwidthAddAllowedListFuzzTest(data, size);
1463     OHOS::NetManagerStandard::BandwidthRemoveAllowedListFuzzTest(data, size);
1464     OHOS::NetManagerStandard::FirewallEnableChainFuzzTest(data, size);
1465     OHOS::NetManagerStandard::GetNetworkSharingTrafficFuzzTest(data, size);
1466     OHOS::NetManagerStandard::NetworkCreateVirtualFuzzTest(data, size);
1467     OHOS::NetManagerStandard::NetworkAddUidsFuzzTest(data, size);
1468     OHOS::NetManagerStandard::NetworkDelUidsFuzzTest(data, size);
1469     OHOS::NetManagerStandard::GetIfaceStatsFuzzTest(data, size);
1470     OHOS::NetManagerStandard::GetUidStatsFuzzTest(data, size);
1471     OHOS::NetManagerStandard::NetworkRemoveRouteParcelFuzzTest(data, size);
1472     OHOS::NetManagerStandard::OnInterfaceAddressUpdatedFuzzTest(data, size);
1473     OHOS::NetManagerStandard::GetCookieStatsFuzzTest(data, size);
1474     OHOS::NetManagerStandard::CmdCreateNetworkCacheFuzzTest(data, size);
1475     OHOS::NetManagerStandard::CmdGetTotalStatsFuzzTest(data, size);
1476     OHOS::NetManagerStandard::CmdSetTcpBufferSizesFuzzTest(data, size);
1477     OHOS::NetManagerStandard::CmdGetAllStatsInfoFuzzTest(data, size);
1478     OHOS::NetManagerStandard::CmdSetIptablesCommandForResFuzzTest(data, size);
1479     OHOS::NetManagerStandard::CmdAddStaticArpFuzzTest(data, size);
1480     OHOS::NetManagerStandard::CmdDelStaticArpFuzzTest(data, size);
1481     OHOS::NetManagerStandard::CmdRegisterDnsResultListenerFuzzTest(data, size);
1482     OHOS::NetManagerStandard::CmdUnregisterDnsResultListenerFuzzTest(data, size);
1483     OHOS::NetManagerStandard::CmdRegisterDnsHealthListenerFuzzTest(data, size);
1484     OHOS::NetManagerStandard::CmdUnregisterDnsHealthListenerFuzzTest(data, size);
1485     OHOS::NetManagerStandard::CmdGetNetworkSharingTypeFuzzTest(data, size);
1486     OHOS::NetManagerStandard::CmdUpdateNetworkSharingTypeFuzzTest(data, size);
1487 }
1488 
LLVMFuzzerTestOneInputOthers(const uint8_t * data,size_t size)1489 void LLVMFuzzerTestOneInputOthers(const uint8_t *data, size_t size)
1490 {
1491     OHOS::NetManagerStandard::CmdSetNetworkAccessPolicyFuzzTest(data, size);
1492     OHOS::NetManagerStandard::CmdDeleteNetworkAccessPolicyFuzzTest(data, size);
1493     OHOS::NetManagerStandard::CmdNotifyNetBearerTypeChangeFuzzTest(data, size);
1494 }
1495 } // namespace NetManagerStandard
1496 } // namespace OHOS
1497 
1498 /* Fuzzer entry point1 */
1499 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1500 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1501 {
1502     /* Run your code on data */
1503     OHOS::NetManagerStandard::NetworkCreatePhysicalFuzzTest(data, size);
1504     OHOS::NetManagerStandard::NetworkDestroyFuzzTest(data, size);
1505     OHOS::NetManagerStandard::NetworkAddInterfaceFuzzTest(data, size);
1506     OHOS::NetManagerStandard::NetworkRemoveInterfaceFuzzTest(data, size);
1507     OHOS::NetManagerStandard::NetworkAddRouteFuzzTest(data, size);
1508     OHOS::NetManagerStandard::NetworkRemoveRouteFuzzTest(data, size);
1509     OHOS::NetManagerStandard::GetInterfaceConfigFuzzTest(data, size);
1510     OHOS::NetManagerStandard::GetInterfaceMtuFuzzTest(data, size);
1511     OHOS::NetManagerStandard::SetInterfaceMtuFuzzTest(data, size);
1512     OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1513     OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1514     OHOS::NetManagerStandard::SetResolverConfigFuzzTest(data, size);
1515     OHOS::NetManagerStandard::GetResolverConfigFuzzTest(data, size);
1516     OHOS::NetManagerStandard::DestroyNetworkCacheFuzzTest(data, size);
1517     OHOS::NetManagerStandard::InterfaceGetListFuzzTest(data, size);
1518     OHOS::NetManagerStandard::ShareDnsSetFuzzTest(data, size);
1519     OHOS::NetManagerStandard::StartDnsProxyListenFuzzTest(data, size);
1520     OHOS::NetManagerStandard::StopDnsProxyListenFuzzTest(data, size);
1521     OHOS::NetManagerStandard::StartDhcpClientFuzzTest(data, size);
1522     OHOS::NetManagerStandard::StopDhcpClientFuzzTest(data, size);
1523     OHOS::NetManagerStandard::StartDhcpServiceFuzzTest(data, size);
1524     OHOS::NetManagerStandard::StopDhcpServiceFuzzTest(data, size);
1525     OHOS::NetManagerStandard::SetIptablesCommandForResFuzzTest(data, size);
1526     OHOS::NetManagerStandard::SetDefaultNetWorkFuzzTest(data, size);
1527     OHOS::NetManagerStandard::SetInterfaceConfigFuzzTest(data, size);
1528     OHOS::NetManagerStandard::IpfwdAddInterfaceForwardFuzzTest(data, size);
1529     OHOS::NetManagerStandard::IpfwdRemoveInterfaceForwardFuzzTest(data, size);
1530     OHOS::NetManagerStandard::InterfaceSetIpAddressFuzzTest(data, size);
1531     OHOS::NetManagerStandard::FirewallSetUidsAllowedListChainFuzzTest(data, size);
1532     OHOS::NetManagerStandard::FirewallSetUidsDeniedListChainFuzzTest(data, size);
1533     OHOS::NetManagerStandard::FirewallSetUidRuleFuzzTest(data, size);
1534     OHOS::NetManagerStandard::LLVMFuzzerTestOneInputNew(data, size);
1535     OHOS::NetManagerStandard::LLVMFuzzerTestOneInputOthers(data, size);
1536     return 0;
1537 }