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