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