• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <thread>
17 
18 #include <securec.h>
19 
20 #include "iservice_registry.h"
21 #include "notify_callback_stub.h"
22 #include "singleton.h"
23 #include "system_ability_definition.h"
24 
25 #include "netsys_native_client.h"
26 #define private public
27 #include "netsys_native_service.h"
28 #include "netsys_native_service_stub.h"
29 
30 namespace OHOS {
31 namespace NetManagerStandard {
32 namespace {
33 const uint8_t *g_baseFuzzData = nullptr;
34 static constexpr uint32_t CONVERT_NUMBER_TO_BOOL = 2;
35 size_t g_baseFuzzSize = 0;
36 size_t g_baseFuzzPos;
37 constexpr size_t STR_LEN = 10;
38 constexpr size_t VECTOR_MAX_SIZE = 15;
39 } // namespace
40 
GetData()41 template <class T> T GetData()
42 {
43     T object{};
44     size_t objectSize = sizeof(object);
45     if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
46         return object;
47     }
48     errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
49     if (ret != EOK) {
50         return {};
51     }
52     g_baseFuzzPos += objectSize;
53     return object;
54 }
55 
GetStringFromData(int strlen)56 std::string GetStringFromData(int strlen)
57 {
58     char cstr[strlen];
59     cstr[strlen - 1] = '\0';
60     for (int i = 0; i < strlen - 1; i++) {
61         cstr[i] = GetData<char>();
62     }
63     std::string str(cstr);
64     return str;
65 }
66 
67 static bool g_isInited = false;
Init()68 void Init()
69 {
70     if (!DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->Init()) {
71         g_isInited = false;
72     } else {
73         g_isInited = true;
74     }
75 }
76 
OnRemoteRequest(uint32_t code,MessageParcel & data)77 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
78 {
79     if (!g_isInited) {
80         Init();
81     }
82 
83     MessageParcel reply;
84     MessageOption option;
85 
86     int32_t ret =
87         DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
88     return ret;
89 }
90 
WriteInterfaceToken(MessageParcel & data)91 bool WriteInterfaceToken(MessageParcel &data)
92 {
93     if (!data.WriteInterfaceToken(NetsysNative::NetsysNativeServiceStub::GetDescriptor())) {
94         return false;
95     }
96     return true;
97 }
98 
WriteInterfaceTokenCallback(MessageParcel & data)99 bool WriteInterfaceTokenCallback(MessageParcel &data)
100 {
101     if (!data.WriteInterfaceToken(NetsysNative::NotifyCallbackStub::GetDescriptor())) {
102         return false;
103     }
104     return true;
105 }
106 
107 class INetSysCallbackTest : public NetsysNative::NotifyCallbackStub {
108 public:
INetSysCallbackTest()109     INetSysCallbackTest() : NotifyCallbackStub() {}
~INetSysCallbackTest()110     virtual ~INetSysCallbackTest() {}
111 };
112 
113 class NetsysControllerCallbackTest : public NetsysControllerCallback {
114 public:
OnInterfaceAddressUpdated(const std::string &,const std::string &,int,int)115     virtual int32_t OnInterfaceAddressUpdated(const std::string &, const std::string &, int, int)
116     {
117         return 0;
118     }
OnInterfaceAddressRemoved(const std::string &,const std::string &,int,int)119     virtual int32_t OnInterfaceAddressRemoved(const std::string &, const std::string &, int, int)
120     {
121         return 0;
122     }
OnInterfaceAdded(const std::string &)123     virtual int32_t OnInterfaceAdded(const std::string &)
124     {
125         return 0;
126     }
OnInterfaceRemoved(const std::string &)127     virtual int32_t OnInterfaceRemoved(const std::string &)
128     {
129         return 0;
130     }
OnInterfaceChanged(const std::string &,bool)131     virtual int32_t OnInterfaceChanged(const std::string &, bool)
132     {
133         return 0;
134     }
OnInterfaceLinkStateChanged(const std::string &,bool)135     virtual int32_t OnInterfaceLinkStateChanged(const std::string &, bool)
136     {
137         return 0;
138     }
OnRouteChanged(bool,const std::string &,const std::string &,const std::string &)139     virtual int32_t OnRouteChanged(bool, const std::string &, const std::string &, const std::string &)
140     {
141         return 0;
142     }
OnDhcpSuccess(NetsysControllerCallback::DhcpResult & dhcpResult)143     virtual int32_t OnDhcpSuccess(NetsysControllerCallback::DhcpResult &dhcpResult)
144     {
145         return 0;
146     }
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)147     virtual int32_t OnBandwidthReachedLimit(const std::string &limitName, const std::string &iface)
148     {
149         return 0;
150     }
151 };
152 
153 static NetsysNative::NetsysNativeService g_netSysNativeClient;
154 
IsDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)155 bool IsDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
156 {
157     if ((data == nullptr) || (size == 0)) {
158         return false;
159     }
160     g_baseFuzzData = data;
161     g_baseFuzzSize = size;
162     g_baseFuzzPos = 0;
163 
164     if (!WriteInterfaceToken(dataParcel)) {
165         return false;
166     }
167     return true;
168 }
169 
NetworkCreatePhysicalFuzzTest(const uint8_t * data,size_t size)170 void NetworkCreatePhysicalFuzzTest(const uint8_t *data, size_t size)
171 {
172     MessageParcel dataParcel;
173     if (!IsDataAndSizeValid(data, size, dataParcel)) {
174         return;
175     }
176 
177     int32_t netId = GetData<int32_t>();
178     int32_t permission = GetData<int32_t>();
179 
180     dataParcel.WriteInt32(netId);
181     dataParcel.WriteInt32(permission);
182     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_PHYSICAL),
183                     dataParcel);
184 }
185 
NetworkDestroyFuzzTest(const uint8_t * data,size_t size)186 void NetworkDestroyFuzzTest(const uint8_t *data, size_t size)
187 {
188     MessageParcel dataParcel;
189     if (!IsDataAndSizeValid(data, size, dataParcel)) {
190         return;
191     }
192 
193     int32_t netId = GetData<int32_t>();
194     dataParcel.WriteInt32(netId);
195     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DESTROY), dataParcel);
196 }
197 
NetworkAddInterfaceFuzzTest(const uint8_t * data,size_t size)198 void NetworkAddInterfaceFuzzTest(const uint8_t *data, size_t size)
199 {
200     MessageParcel dataParcel;
201     if (!IsDataAndSizeValid(data, size, dataParcel)) {
202         return;
203     }
204 
205     int32_t netId = GetData<int32_t>();
206     std::string iface = GetStringFromData(STR_LEN);
207 
208     dataParcel.WriteInt32(netId);
209     dataParcel.WriteString(iface);
210     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_INTERFACE), dataParcel);
211 }
212 
NetworkRemoveInterfaceFuzzTest(const uint8_t * data,size_t size)213 void NetworkRemoveInterfaceFuzzTest(const uint8_t *data, size_t size)
214 {
215     MessageParcel dataParcel;
216     if (!IsDataAndSizeValid(data, size, dataParcel)) {
217         return;
218     }
219 
220     int32_t netId = GetData<int32_t>();
221     std::string iface = GetStringFromData(STR_LEN);
222 
223     dataParcel.WriteInt32(netId);
224     dataParcel.WriteString(iface);
225     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_INTERFACE),
226                     dataParcel);
227 }
228 
NetworkAddRouteFuzzTest(const uint8_t * data,size_t size)229 void NetworkAddRouteFuzzTest(const uint8_t *data, size_t size)
230 {
231     MessageParcel dataParcel;
232     if (!IsDataAndSizeValid(data, size, dataParcel)) {
233         return;
234     }
235 
236     int32_t netId = GetData<int32_t>();
237     std::string ifName = GetStringFromData(STR_LEN);
238     std::string destination = GetStringFromData(STR_LEN);
239     std::string nextHop = GetStringFromData(STR_LEN);
240 
241     dataParcel.WriteInt32(netId);
242     dataParcel.WriteString(ifName);
243     dataParcel.WriteString(destination);
244     dataParcel.WriteString(nextHop);
245     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE), dataParcel);
246 }
247 
NetworkRemoveRouteFuzzTest(const uint8_t * data,size_t size)248 void NetworkRemoveRouteFuzzTest(const uint8_t *data, size_t size)
249 {
250     MessageParcel dataParcel;
251     if (!IsDataAndSizeValid(data, size, dataParcel)) {
252         return;
253     }
254 
255     int32_t netId = GetData<int32_t>();
256     std::string ifName = GetStringFromData(STR_LEN);
257     std::string destination = GetStringFromData(STR_LEN);
258     std::string nextHop = GetStringFromData(STR_LEN);
259 
260     dataParcel.WriteInt32(netId);
261     dataParcel.WriteString(ifName);
262     dataParcel.WriteString(destination);
263     dataParcel.WriteString(nextHop);
264     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_ROUTE), dataParcel);
265 }
266 
GetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)267 void GetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
268 {
269     MessageParcel dataParcel;
270     if (!IsDataAndSizeValid(data, size, dataParcel)) {
271         return;
272     }
273 
274     OHOS::nmd::InterfaceConfigurationParcel cfg;
275     cfg.ifName = GetStringFromData(STR_LEN);
276 
277     dataParcel.WriteString(cfg.ifName);
278     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_CONFIG), dataParcel);
279 }
280 
GetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)281 void GetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
282 {
283     MessageParcel dataParcel;
284     if (!IsDataAndSizeValid(data, size, dataParcel)) {
285         return;
286     }
287 
288     std::string interfaceName = GetStringFromData(STR_LEN);
289 
290     dataParcel.WriteString(interfaceName);
291     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_MTU), dataParcel);
292 }
293 
SetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)294 void SetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
295 {
296     MessageParcel dataParcel;
297     if (!IsDataAndSizeValid(data, size, dataParcel)) {
298         return;
299     }
300 
301     int32_t mtu = GetData<int32_t>();
302     std::string interfaceName = GetStringFromData(STR_LEN);
303 
304     dataParcel.WriteString(interfaceName);
305     dataParcel.WriteInt32(mtu);
306     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_MTU), dataParcel);
307 }
308 
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)309 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
310 {
311     MessageParcel dataParcel;
312     if (!IsDataAndSizeValid(data, size, dataParcel)) {
313         return;
314     }
315 
316     std::string interfaceName = GetStringFromData(STR_LEN);
317     std::string ipAddr = GetStringFromData(STR_LEN);
318     int32_t prefixLength = GetData<int32_t>();
319 
320     dataParcel.WriteString(interfaceName);
321     dataParcel.WriteString(ipAddr);
322     dataParcel.WriteInt32(prefixLength);
323     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_ADD_ADDRESS), dataParcel);
324 }
325 
326 class TestNotifyCallback : public NetsysNative::NotifyCallbackStub {
327 public:
328     TestNotifyCallback() = default;
~TestNotifyCallback()329     ~TestNotifyCallback(){};
OnInterfaceAddressUpdated(const std::string & addr,const std::string & ifName,int flags,int scope)330     int32_t OnInterfaceAddressUpdated(const std::string &addr, const std::string &ifName, int flags, int scope)
331     {
332         return 0;
333     }
334 
OnInterfaceAddressRemoved(const std::string & addr,const std::string & ifName,int flags,int scope)335     int32_t OnInterfaceAddressRemoved(const std::string &addr, const std::string &ifName, int flags, int scope)
336     {
337         return 0;
338     }
339 
OnInterfaceAdded(const std::string & ifName)340     int32_t OnInterfaceAdded(const std::string &ifName)
341     {
342         return 0;
343     }
344 
OnInterfaceRemoved(const std::string & ifName)345     int32_t OnInterfaceRemoved(const std::string &ifName)
346     {
347         return 0;
348     }
349 
OnInterfaceChanged(const std::string & ifName,bool up)350     int32_t OnInterfaceChanged(const std::string &ifName, bool up)
351     {
352         return 0;
353     }
354 
OnInterfaceLinkStateChanged(const std::string & ifName,bool up)355     int32_t OnInterfaceLinkStateChanged(const std::string &ifName, bool up)
356     {
357         return 0;
358     }
359 
OnRouteChanged(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)360     int32_t OnRouteChanged(bool updated, const std::string &route, const std::string &gateway,
361                            const std::string &ifName)
362     {
363         return 0;
364     }
365 
OnDhcpSuccess(sptr<OHOS::NetsysNative::DhcpResultParcel> & dhcpResult)366     int32_t OnDhcpSuccess(sptr<OHOS::NetsysNative::DhcpResultParcel> &dhcpResult)
367     {
368         return 0;
369     }
370 
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)371     int32_t OnBandwidthReachedLimit(const std::string &limitName, const std::string &iface)
372     {
373         return 0;
374     }
375 };
376 
RegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)377 void RegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
378 {
379     MessageParcel dataParcel;
380     if (!IsDataAndSizeValid(data, size, dataParcel)) {
381         return;
382     }
383 
384     sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) TestNotifyCallback();
385 
386     notifyCb->Marshalling(dataParcel);
387     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_REGISTER_NOTIFY_CALLBACK),
388                     dataParcel);
389 }
390 
UnRegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)391 void UnRegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
392 {
393     MessageParcel dataParcel;
394     if (!IsDataAndSizeValid(data, size, dataParcel)) {
395         return;
396     }
397 
398     sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) TestNotifyCallback();
399 
400     notifyCb->Marshalling(dataParcel);
401     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UNREGISTER_NOTIFY_CALLBACK),
402                     dataParcel);
403 }
404 
InterfaceSetIffUpFuzzTest(const uint8_t * data,size_t size)405 void InterfaceSetIffUpFuzzTest(const uint8_t *data, size_t size)
406 {
407     MessageParcel dataParcel;
408     if (!IsDataAndSizeValid(data, size, dataParcel)) {
409         return;
410     }
411 
412     std::string ifaceName = GetStringFromData(STR_LEN);
413 
414     if (!dataParcel.WriteString("-L -n")) {
415         return;
416     }
417 
418     dataParcel.WriteString(ifaceName);
419     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IFF_UP), dataParcel);
420 }
421 
GetAddrInfoFuzzTest(const uint8_t * data,size_t size)422 void GetAddrInfoFuzzTest(const uint8_t *data, size_t size)
423 {
424     MessageParcel dataParcel;
425     if (!IsDataAndSizeValid(data, size, dataParcel)) {
426         return;
427     }
428 
429     std::string serverName = GetStringFromData(STR_LEN);
430     AddrInfo hints;
431     hints.aiFlags = GetData<uint32_t>();
432     hints.aiFamily = GetData<uint32_t>();
433     hints.aiSockType = GetData<uint32_t>();
434     hints.aiProtocol = GetData<uint32_t>();
435     hints.aiAddrLen = GetData<uint32_t>();
436 
437     std::string aiCanName = GetStringFromData(STR_LEN);
438     if (memcpy_s(hints.aiCanonName, sizeof(hints.aiCanonName), aiCanName.c_str(), aiCanName.length()) != 0) {
439         return;
440     }
441     uint16_t netId = GetData<uint16_t>();
442 
443     if (!dataParcel.WriteString("-L -n")) {
444         return;
445     }
446 
447     dataParcel.WriteString(serverName);
448     dataParcel.WriteUint32(hints.aiFlags);
449     dataParcel.WriteUint32(hints.aiFamily);
450     dataParcel.WriteUint32(hints.aiSockType);
451     dataParcel.WriteUint32(hints.aiProtocol);
452     dataParcel.WriteUint32(hints.aiAddrLen);
453     dataParcel.WriteString(hints.aiCanonName);
454     dataParcel.WriteUint16(netId);
455     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ADDR_INFO), dataParcel);
456 }
457 
NetworkAddRouteParcelFuzzTest(const uint8_t * data,size_t size)458 void NetworkAddRouteParcelFuzzTest(const uint8_t *data, size_t size)
459 {
460     MessageParcel dataParcel;
461     if (!IsDataAndSizeValid(data, size, dataParcel)) {
462         return;
463     }
464 
465     int32_t netId = GetData<int32_t>();
466     NetsysNative::RouteInfoParcel routInfo;
467     routInfo.destination = GetStringFromData(STR_LEN);
468     routInfo.ifName = GetStringFromData(STR_LEN);
469     routInfo.nextHop = GetStringFromData(STR_LEN);
470     routInfo.mtu = GetData<int32_t>();
471 
472     dataParcel.WriteInt32(netId);
473     dataParcel.WriteString(routInfo.destination);
474     dataParcel.WriteString(routInfo.ifName);
475     dataParcel.WriteString(routInfo.nextHop);
476     dataParcel.WriteInt32(routInfo.mtu);
477     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE_PARCEL),
478                     dataParcel);
479 }
480 
NetworkSetDefaultFuzzTest(const uint8_t * data,size_t size)481 void NetworkSetDefaultFuzzTest(const uint8_t *data, size_t size)
482 {
483     MessageParcel dataParcel;
484     if (!IsDataAndSizeValid(data, size, dataParcel)) {
485         return;
486     }
487 
488     int32_t netId = GetData<int32_t>();
489 
490     dataParcel.WriteInt32(netId);
491     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_SET_DEFAULT), dataParcel);
492 }
493 
NetworkGetDefaultFuzzTest(const uint8_t * data,size_t size)494 void NetworkGetDefaultFuzzTest(const uint8_t *data, size_t size)
495 {
496     MessageParcel dataParcel;
497     if (!IsDataAndSizeValid(data, size, dataParcel)) {
498         return;
499     }
500     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_GET_DEFAULT), dataParcel);
501 }
SetDefaultNetWorkFuzzTest(const uint8_t * data,size_t size)502 void SetDefaultNetWorkFuzzTest(const uint8_t *data, size_t size)
503 {
504     MessageParcel dataParcel;
505     if (!IsDataAndSizeValid(data, size, dataParcel)) {
506         return;
507     }
508 
509     int32_t netId = GetData<int32_t>();
510 
511     dataParcel.WriteInt32(netId);
512     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_CONFIG), dataParcel);
513 }
514 
IpfwdAddInterfaceForwardFuzzTest(const uint8_t * data,size_t size)515 void IpfwdAddInterfaceForwardFuzzTest(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 = GetStringFromData(STR_LEN);
523     std::string toIface = GetStringFromData(STR_LEN);
524 
525     dataParcel.WriteString(fromIface);
526     dataParcel.WriteString(toIface);
527     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_ADD_INTERFACE_FORWARD),
528                     dataParcel);
529 }
530 
IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t * data,size_t size)531 void IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t *data, size_t size)
532 {
533     MessageParcel dataParcel;
534     if (!IsDataAndSizeValid(data, size, dataParcel)) {
535         return;
536     }
537 
538     std::string fromIface = GetStringFromData(STR_LEN);
539     std::string toIface = GetStringFromData(STR_LEN);
540 
541     dataParcel.WriteString(fromIface);
542     dataParcel.WriteString(toIface);
543     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_REMOVE_INTERFACE_FORWARD),
544                     dataParcel);
545 }
546 
InterfaceSetIpAddressFuzzTest(const uint8_t * data,size_t size)547 void InterfaceSetIpAddressFuzzTest(const uint8_t *data, size_t size)
548 {
549     MessageParcel dataParcel;
550     if (!IsDataAndSizeValid(data, size, dataParcel)) {
551         return;
552     }
553 
554     std::string ifaceName = GetStringFromData(STR_LEN);
555     std::string ipAddress = GetStringFromData(STR_LEN);
556 
557     dataParcel.WriteString(ifaceName);
558     dataParcel.WriteString(ipAddress);
559     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IP_ADDRESS),
560                     dataParcel);
561 }
562 
FirewallSetUidsAllowedListChainFuzzTest(const uint8_t * data,size_t size)563 void FirewallSetUidsAllowedListChainFuzzTest(const uint8_t *data, size_t size)
564 {
565     MessageParcel dataParcel;
566     if (!IsDataAndSizeValid(data, size, dataParcel)) {
567         return;
568     }
569 
570     std::string ifaceName = GetStringFromData(STR_LEN);
571     std::string ipAddress = GetStringFromData(STR_LEN);
572 
573     dataParcel.WriteString(ifaceName);
574     dataParcel.WriteString(ipAddress);
575     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IP_ADDRESS),
576                     dataParcel);
577 }
578 
FirewallSetUidsDeniedListChainFuzzTest(const uint8_t * data,size_t size)579 void FirewallSetUidsDeniedListChainFuzzTest(const uint8_t *data, size_t size)
580 {
581     MessageParcel dataParcel;
582     if (!IsDataAndSizeValid(data, size, dataParcel)) {
583         return;
584     }
585 
586     std::string ifaceName = GetStringFromData(STR_LEN);
587     std::string ipAddress = GetStringFromData(STR_LEN);
588 
589     dataParcel.WriteString(ifaceName);
590     dataParcel.WriteString(ipAddress);
591     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_DENIED_LIST_CHAIN),
592                     dataParcel);
593 }
594 
FirewallSetUidRuleFuzzTest(const uint8_t * data,size_t size)595 void FirewallSetUidRuleFuzzTest(const uint8_t *data, size_t size)
596 {
597     MessageParcel dataParcel;
598     if (!IsDataAndSizeValid(data, size, dataParcel)) {
599         return;
600     }
601 
602     int32_t chain = GetData<int32_t>();
603     int32_t firewallRule = GetData<int32_t>();
604 
605     uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
606     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
607     for (uint32_t i = 0; i <= vectorLength; i++) {
608         dataParcel.WriteInt32(GetData<uint32_t>());
609     }
610 
611     dataParcel.WriteInt32(chain);
612     dataParcel.WriteInt32(firewallRule);
613 
614     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_RULE), dataParcel);
615 }
SetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)616 void SetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
617 {
618     MessageParcel dataParcel;
619     if (!IsDataAndSizeValid(data, size, dataParcel)) {
620         return;
621     }
622 
623     OHOS::nmd::InterfaceConfigurationParcel cfg;
624     cfg.ifName = GetStringFromData(STR_LEN);
625     cfg.hwAddr = GetStringFromData(STR_LEN);
626     cfg.ipv4Addr = GetStringFromData(STR_LEN);
627     cfg.prefixLength = GetData<int32_t>();
628 
629     uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
630     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
631     for (uint32_t i = 0; i <= vectorLength; i++) {
632         dataParcel.WriteString(GetStringFromData(STR_LEN));
633     }
634 
635     dataParcel.WriteString(cfg.ifName);
636     dataParcel.WriteString(cfg.hwAddr);
637     dataParcel.WriteString(cfg.ipv4Addr);
638     dataParcel.WriteInt32(cfg.prefixLength);
639     dataParcel.WriteInt32(cfg.flags.size());
640     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_CONFIG), dataParcel);
641 }
642 
NetworkClearDefaultFuzzTest(const uint8_t * data,size_t size)643 void NetworkClearDefaultFuzzTest(const uint8_t *data, size_t size)
644 {
645     MessageParcel dataParcel;
646     if (!IsDataAndSizeValid(data, size, dataParcel)) {
647         return;
648     }
649     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CLEAR_DEFAULT), dataParcel);
650 }
651 
GetProcSysNetFuzzTest(const uint8_t * data,size_t size)652 void GetProcSysNetFuzzTest(const uint8_t *data, size_t size)
653 {
654     MessageParcel dataParcel;
655     if (!IsDataAndSizeValid(data, size, dataParcel)) {
656         return;
657     }
658 
659     int32_t family = GetData<int32_t>();
660     int32_t which = GetData<int32_t>();
661     std::string ifname = GetStringFromData(STR_LEN);
662     std::string parameter = GetStringFromData(STR_LEN);
663     std::string value = GetStringFromData(STR_LEN);
664 
665     dataParcel.WriteInt32(family);
666     dataParcel.WriteInt32(which);
667     dataParcel.WriteString(ifname);
668     dataParcel.WriteString(parameter);
669     dataParcel.WriteString(value);
670     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_PROC_SYS_NET), dataParcel);
671 }
672 
SetProcSysNetFuzzTest(const uint8_t * data,size_t size)673 void SetProcSysNetFuzzTest(const uint8_t *data, size_t size)
674 {
675     MessageParcel dataParcel;
676     if (!IsDataAndSizeValid(data, size, dataParcel)) {
677         return;
678     }
679 
680     int32_t family = GetData<int32_t>();
681     int32_t which = GetData<int32_t>();
682     std::string ifname = GetStringFromData(STR_LEN);
683     std::string parameter = GetStringFromData(STR_LEN);
684     std::string value = GetStringFromData(STR_LEN);
685 
686     dataParcel.WriteInt32(family);
687     dataParcel.WriteInt32(which);
688     dataParcel.WriteString(ifname);
689     dataParcel.WriteString(parameter);
690     dataParcel.WriteString(value);
691     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_RULE), dataParcel);
692 }
693 
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)694 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
695 {
696     MessageParcel dataParcel;
697     if (!IsDataAndSizeValid(data, size, dataParcel)) {
698         return;
699     }
700 
701     int32_t uid = GetData<int32_t>();
702     int8_t allow = GetData<int8_t>();
703 
704     dataParcel.WriteInt32(uid);
705     dataParcel.WriteInt32(allow);
706     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_INTERNET_PERMISSION),
707                     dataParcel);
708 }
709 
GetFwmarkForNetworkFuzzTest(const uint8_t * data,size_t size)710 void GetFwmarkForNetworkFuzzTest(const uint8_t *data, size_t size)
711 {
712     MessageParcel dataParcel;
713     if (!IsDataAndSizeValid(data, size, dataParcel)) {
714         return;
715     }
716 
717     uint32_t netId = GetData<uint32_t>();
718     NetsysNative::MarkMaskParcel markParcl;
719     markParcl.mark = GetData<int32_t>();
720     markParcl.mask = GetData<int32_t>();
721 
722     dataParcel.WriteInt32(netId);
723     dataParcel.WriteInt32(markParcl.mark);
724     dataParcel.WriteInt32(markParcl.mask);
725     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_FWMARK_FOR_NETWORK),
726                     dataParcel);
727 }
728 
IpEnableForwardingFuzzTest(const uint8_t * data,size_t size)729 void IpEnableForwardingFuzzTest(const uint8_t *data, size_t size)
730 {
731     MessageParcel dataParcel;
732     if (!IsDataAndSizeValid(data, size, dataParcel)) {
733         return;
734     }
735 
736     std::string requestor = GetStringFromData(STR_LEN);
737 
738     dataParcel.WriteString(requestor);
739     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPENABLE_FORWARDING), dataParcel);
740 }
741 
IpDisableForwardingFuzzTest(const uint8_t * data,size_t size)742 void IpDisableForwardingFuzzTest(const uint8_t *data, size_t size)
743 {
744     MessageParcel dataParcel;
745     if (!IsDataAndSizeValid(data, size, dataParcel)) {
746         return;
747     }
748 
749     std::string requestor = GetStringFromData(STR_LEN);
750 
751     dataParcel.WriteString(requestor);
752     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPDISABLE_FORWARDING), dataParcel);
753 }
754 
EnableNatFuzzTest(const uint8_t * data,size_t size)755 void EnableNatFuzzTest(const uint8_t *data, size_t size)
756 {
757     MessageParcel dataParcel;
758     if (!IsDataAndSizeValid(data, size, dataParcel)) {
759         return;
760     }
761 
762     std::string downstreamIface = GetStringFromData(STR_LEN);
763     std::string upstreamIface = GetStringFromData(STR_LEN);
764 
765     dataParcel.WriteString(downstreamIface);
766     dataParcel.WriteString(upstreamIface);
767     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_ENABLE_NAT), dataParcel);
768 }
769 
DisableNatFuzzTest(const uint8_t * data,size_t size)770 void DisableNatFuzzTest(const uint8_t *data, size_t size)
771 {
772     MessageParcel dataParcel;
773     if (!IsDataAndSizeValid(data, size, dataParcel)) {
774         return;
775     }
776 
777     std::string downstreamIface = GetStringFromData(STR_LEN);
778     std::string upstreamIface = GetStringFromData(STR_LEN);
779 
780     dataParcel.WriteString(downstreamIface);
781     dataParcel.WriteString(upstreamIface);
782     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DISABLE_NAT), dataParcel);
783 }
784 
BandwidthEnableDataSaverFuzzTest(const uint8_t * data,size_t size)785 void BandwidthEnableDataSaverFuzzTest(const uint8_t *data, size_t size)
786 {
787     MessageParcel dataParcel;
788     if (!IsDataAndSizeValid(data, size, dataParcel)) {
789         return;
790     }
791 
792     bool enable = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
793 
794     dataParcel.WriteBool(enable);
795     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ENABLE_DATA_SAVER),
796                     dataParcel);
797 }
798 
BandwidthSetIfaceQuotaFuzzTest(const uint8_t * data,size_t size)799 void BandwidthSetIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
800 {
801     MessageParcel dataParcel;
802     if (!IsDataAndSizeValid(data, size, dataParcel)) {
803         return;
804     }
805 
806     int64_t bytes = GetData<int64_t>();
807     std::string ifName = GetStringFromData(STR_LEN);
808 
809     dataParcel.WriteInt64(bytes);
810     dataParcel.WriteString(ifName);
811     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_SET_IFACE_QUOTA),
812                     dataParcel);
813 }
814 
BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t * data,size_t size)815 void BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
816 {
817     MessageParcel dataParcel;
818     if (!IsDataAndSizeValid(data, size, dataParcel)) {
819         return;
820     }
821 
822     std::string ifName = GetStringFromData(STR_LEN);
823 
824     dataParcel.WriteString(ifName);
825     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_IFACE_QUOTA),
826                     dataParcel);
827 }
828 
BandwidthAddDeniedListFuzzTest(const uint8_t * data,size_t size)829 void BandwidthAddDeniedListFuzzTest(const uint8_t *data, size_t size)
830 {
831     MessageParcel dataParcel;
832     if (!IsDataAndSizeValid(data, size, dataParcel)) {
833         return;
834     }
835 
836     uint32_t uid = GetData<uint32_t>();
837 
838     dataParcel.WriteInt32(uid);
839     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_DENIED_LIST),
840                     dataParcel);
841 }
842 
BandwidthRemoveDeniedListFuzzTest(const uint8_t * data,size_t size)843 void BandwidthRemoveDeniedListFuzzTest(const uint8_t *data, size_t size)
844 {
845     MessageParcel dataParcel;
846     if (!IsDataAndSizeValid(data, size, dataParcel)) {
847         return;
848     }
849 
850     uint32_t uid = GetData<uint32_t>();
851 
852     dataParcel.WriteInt32(uid);
853     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_DENIED_LIST),
854                     dataParcel);
855 }
856 
BandwidthAddAllowedListFuzzTest(const uint8_t * data,size_t size)857 void BandwidthAddAllowedListFuzzTest(const uint8_t *data, size_t size)
858 {
859     MessageParcel dataParcel;
860     if (!IsDataAndSizeValid(data, size, dataParcel)) {
861         return;
862     }
863 
864     uint32_t uid = GetData<uint32_t>();
865 
866     dataParcel.WriteInt32(uid);
867     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_ALLOWED_LIST),
868                     dataParcel);
869 }
870 
BandwidthRemoveAllowedListFuzzTest(const uint8_t * data,size_t size)871 void BandwidthRemoveAllowedListFuzzTest(const uint8_t *data, size_t size)
872 {
873     MessageParcel dataParcel;
874     if (!IsDataAndSizeValid(data, size, dataParcel)) {
875         return;
876     }
877 
878     uint32_t uid = GetData<uint32_t>();
879 
880     dataParcel.WriteInt32(uid);
881     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_ALLOWED_LIST),
882                     dataParcel);
883 }
884 
FirewallEnableChainFuzzTest(const uint8_t * data,size_t size)885 void FirewallEnableChainFuzzTest(const uint8_t *data, size_t size)
886 {
887     MessageParcel dataParcel;
888     if (!IsDataAndSizeValid(data, size, dataParcel)) {
889         return;
890     }
891 
892     uint32_t chain = GetData<uint32_t>();
893     bool enable = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
894 
895     dataParcel.WriteInt32(chain);
896     dataParcel.WriteBool(enable);
897     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_ENABLE_CHAIN), dataParcel);
898 }
899 
GetNetworkSharingTrafficFuzzTest(const uint8_t * data,size_t size)900 void GetNetworkSharingTrafficFuzzTest(const uint8_t *data, size_t size)
901 {
902     MessageParcel dataParcel;
903     if (!IsDataAndSizeValid(data, size, dataParcel)) {
904         return;
905     }
906 
907     std::string downIface = GetStringFromData(STR_LEN);
908     std::string upIface = GetStringFromData(STR_LEN);
909     NetsysNative::NetworkSharingTraffic traffic;
910     traffic.receive = GetData<int64_t>();
911     traffic.send = GetData<int64_t>();
912     traffic.all = GetData<int64_t>();
913 
914     dataParcel.WriteString(downIface);
915     dataParcel.WriteString(upIface);
916     dataParcel.WriteInt64(traffic.receive);
917     dataParcel.WriteInt64(traffic.send);
918     dataParcel.WriteInt64(traffic.all);
919     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_SHARING_NETWORK_TRAFFIC),
920                     dataParcel);
921 }
922 
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)923 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
924 {
925     MessageParcel dataParcel;
926     if (!IsDataAndSizeValid(data, size, dataParcel)) {
927         return;
928     }
929 
930     std::string interfaceName = GetStringFromData(STR_LEN);
931     std::string ipAddr = GetStringFromData(STR_LEN);
932     int32_t prefixLength = GetData<int32_t>();
933 
934     dataParcel.WriteString(interfaceName);
935     dataParcel.WriteString(ipAddr);
936     dataParcel.WriteInt32(prefixLength);
937     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_DEL_ADDRESS), dataParcel);
938 }
939 
SetResolverConfigFuzzTest(const uint8_t * data,size_t size)940 void SetResolverConfigFuzzTest(const uint8_t *data, size_t size)
941 {
942     MessageParcel dataParcel;
943     if (!IsDataAndSizeValid(data, size, dataParcel)) {
944         return;
945     }
946 
947     uint16_t netId = GetData<uint16_t>();
948     uint16_t baseTimeoutMsec = GetData<uint16_t>();
949     uint8_t retryCount = GetData<uint8_t>();
950 
951     dataParcel.WriteUint16(netId);
952     dataParcel.WriteUint16(baseTimeoutMsec);
953     dataParcel.WriteUint8(retryCount);
954 
955     uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
956     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
957     for (uint32_t i = 0; i <= vectorLength; i++) {
958         dataParcel.WriteString(GetStringFromData(STR_LEN));
959     }
960 
961     uint32_t vectorLength2 = GetData<uint32_t>() % VECTOR_MAX_SIZE;
962     dataParcel.WriteInt32(static_cast<int32_t>(vectorLength2));
963     for (uint32_t i = 0; i <= vectorLength2; i++) {
964         dataParcel.WriteString(GetStringFromData(STR_LEN));
965     }
966     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_RESOLVER_CONFIG), dataParcel);
967 }
968 
GetResolverConfigFuzzTest(const uint8_t * data,size_t size)969 void GetResolverConfigFuzzTest(const uint8_t *data, size_t size)
970 {
971     MessageParcel dataParcel;
972     if (!IsDataAndSizeValid(data, size, dataParcel)) {
973         return;
974     }
975 
976     uint16_t netId = GetData<uint16_t>();
977 
978     dataParcel.WriteUint16(netId);
979     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_RESOLVER_CONFIG), dataParcel);
980 }
981 
CreateNetworkCacheFuzzTest(const uint8_t * data,size_t size)982 void CreateNetworkCacheFuzzTest(const uint8_t *data, size_t size)
983 {
984     MessageParcel dataParcel;
985     if (!IsDataAndSizeValid(data, size, dataParcel)) {
986         return;
987     }
988 
989     uint16_t netId = GetData<uint16_t>();
990 
991     dataParcel.WriteUint16(netId);
992     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_CREATE_NETWORK_CACHE), dataParcel);
993 }
994 
DestroyNetworkCacheFuzzTest(const uint8_t * data,size_t size)995 void DestroyNetworkCacheFuzzTest(const uint8_t *data, size_t size)
996 {
997     MessageParcel dataParcel;
998     if (!IsDataAndSizeValid(data, size, dataParcel)) {
999         return;
1000     }
1001 
1002     uint16_t netId = GetData<uint16_t>();
1003 
1004     dataParcel.WriteUint16(netId);
1005     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DESTROY_NETWORK_CACHE), dataParcel);
1006 }
1007 
InterfaceGetListFuzzTest(const uint8_t * data,size_t size)1008 void InterfaceGetListFuzzTest(const uint8_t *data, size_t size)
1009 {
1010     MessageParcel dataParcel;
1011     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1012         return;
1013     }
1014     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_LIST), dataParcel);
1015 }
1016 
ShareDnsSetFuzzTest(const uint8_t * data,size_t size)1017 void ShareDnsSetFuzzTest(const uint8_t *data, size_t size)
1018 {
1019     MessageParcel dataParcel;
1020     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1021         return;
1022     }
1023     uint16_t netId = GetData<uint16_t>();
1024     dataParcel.WriteUint16(netId);
1025     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_TETHER_DNS_SET), dataParcel);
1026 }
1027 
StartDnsProxyListenFuzzTest(const uint8_t * data,size_t size)1028 void StartDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
1029 {
1030     MessageParcel dataParcel;
1031     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1032         return;
1033     }
1034     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DNS_PROXY_LISTEN),
1035                     dataParcel);
1036 }
1037 
StopDnsProxyListenFuzzTest(const uint8_t * data,size_t size)1038 void StopDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
1039 {
1040     MessageParcel dataParcel;
1041     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1042         return;
1043     }
1044     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DNS_PROXY_LISTEN), dataParcel);
1045 }
1046 
StartDhcpClientFuzzTest(const uint8_t * data,size_t size)1047 void StartDhcpClientFuzzTest(const uint8_t *data, size_t size)
1048 {
1049     MessageParcel dataParcel;
1050     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1051         return;
1052     }
1053     std::string iface = GetStringFromData(STR_LEN);
1054     bool bIpv6 = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1055     dataParcel.WriteString(iface);
1056     dataParcel.WriteBool(bIpv6);
1057     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_CLIENT), dataParcel);
1058 }
1059 
StopDhcpClientFuzzTest(const uint8_t * data,size_t size)1060 void StopDhcpClientFuzzTest(const uint8_t *data, size_t size)
1061 {
1062     MessageParcel dataParcel;
1063     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1064         return;
1065     }
1066     std::string iface = GetStringFromData(STR_LEN);
1067     bool bIpv6 = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1068 
1069     dataParcel.WriteString(iface);
1070     dataParcel.WriteBool(bIpv6);
1071     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_CLIENT), dataParcel);
1072 }
1073 
StartDhcpServiceFuzzTest(const uint8_t * data,size_t size)1074 void StartDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1075 {
1076     MessageParcel dataParcel;
1077     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1078         return;
1079     }
1080     std::string iface = GetStringFromData(STR_LEN);
1081     std::string ipv4addr = GetStringFromData(STR_LEN);
1082     dataParcel.WriteString(iface);
1083     dataParcel.WriteString(ipv4addr);
1084     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_SERVICE), dataParcel);
1085 }
1086 
StopDhcpServiceFuzzTest(const uint8_t * data,size_t size)1087 void StopDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1088 {
1089     MessageParcel dataParcel;
1090     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1091         return;
1092     }
1093     std::string iface = GetStringFromData(STR_LEN);
1094     dataParcel.WriteString(iface);
1095     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_SERVICE), dataParcel);
1096 }
1097 
GetTotalStatsFuzzTest(const uint8_t * data,size_t size)1098 void GetTotalStatsFuzzTest(const uint8_t *data, size_t size)
1099 {
1100     MessageParcel dataParcel;
1101     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1102         return;
1103     }
1104 
1105     uint32_t type = GetData<uint32_t>();
1106     dataParcel.WriteUint32(type);
1107     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_TOTAL_STATS), dataParcel);
1108 }
1109 
GetUidStatsFuzzTest(const uint8_t * data,size_t size)1110 void GetUidStatsFuzzTest(const uint8_t *data, size_t size)
1111 {
1112     MessageParcel dataParcel;
1113     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1114         return;
1115     }
1116     uint32_t type = GetData<uint32_t>();
1117     uint32_t uid = GetData<uint32_t>();
1118 
1119     dataParcel.WriteUint32(type);
1120     dataParcel.WriteUint32(uid);
1121     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_UID_STATS), dataParcel);
1122 }
1123 
GetIfaceStatsFuzzTest(const uint8_t * data,size_t size)1124 void GetIfaceStatsFuzzTest(const uint8_t *data, size_t size)
1125 {
1126     MessageParcel dataParcel;
1127     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1128         return;
1129     }
1130     uint32_t type = GetData<uint32_t>();
1131     std::string iface = GetStringFromData(STR_LEN);
1132 
1133     dataParcel.WriteUint32(type);
1134     dataParcel.WriteString(iface);
1135     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_IFACE_STATS), dataParcel);
1136 }
1137 
GetAllStatsInfoFuzzTest(const uint8_t * data,size_t size)1138 void GetAllStatsInfoFuzzTest(const uint8_t *data, size_t size)
1139 {
1140     MessageParcel dataParcel;
1141     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1142         return;
1143     }
1144 
1145     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ALL_STATS_INFO), dataParcel);
1146 }
1147 
SetIptablesCommandForResFuzzTest(const uint8_t * data,size_t size)1148 void SetIptablesCommandForResFuzzTest(const uint8_t *data, size_t size)
1149 {
1150     MessageParcel dataParcel;
1151     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1152         return;
1153     }
1154     if (!dataParcel.WriteString("-L -n")) {
1155         return;
1156     }
1157 
1158     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_IPTABLES_CMD_FOR_RES),
1159                     dataParcel);
1160 }
1161 
NetworkCreateVirtualFuzzTest(const uint8_t * data,size_t size)1162 void NetworkCreateVirtualFuzzTest(const uint8_t *data, size_t size)
1163 {
1164     MessageParcel dataParcel;
1165     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1166         return;
1167     }
1168 
1169     int32_t netId = GetData<int32_t>();
1170     bool hasDns = GetData<bool>();
1171 
1172     dataParcel.WriteInt32(netId);
1173     dataParcel.WriteBool(hasDns);
1174 
1175     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_VIRTUAL),
1176                     dataParcel);
1177 }
1178 
NetworkAddUidsFuzzTest(const uint8_t * data,size_t size)1179 void NetworkAddUidsFuzzTest(const uint8_t *data, size_t size)
1180 {
1181     MessageParcel dataParcel;
1182     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1183         return;
1184     }
1185 
1186     int32_t netId = GetData<int32_t>();
1187     std::vector<UidRange> uidRanges;
1188     UidRange uid;
1189     int32_t rangesSize = GetData<int32_t>() % VECTOR_MAX_SIZE;
1190     for (int i = 0; i < rangesSize; i++) {
1191         uidRanges.emplace_back(uid);
1192     }
1193 
1194     dataParcel.WriteInt32(netId);
1195     dataParcel.WriteInt32(rangesSize);
1196     for (auto iter : uidRanges) {
1197         iter.Marshalling(dataParcel);
1198     }
1199 
1200     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_UIDS), dataParcel);
1201 }
1202 
NetworkDelUidsFuzzTest(const uint8_t * data,size_t size)1203 void NetworkDelUidsFuzzTest(const uint8_t *data, size_t size)
1204 {
1205     MessageParcel dataParcel;
1206     if (!IsDataAndSizeValid(data, size, dataParcel)) {
1207         return;
1208     }
1209 
1210     int32_t netId = GetData<int32_t>();
1211     std::vector<UidRange> uidRanges;
1212     UidRange uid;
1213     int32_t rangesSize = GetData<int32_t>() % VECTOR_MAX_SIZE;
1214     for (int i = 0; i < rangesSize; i++) {
1215         uidRanges.emplace_back(uid);
1216     }
1217 
1218     dataParcel.WriteInt32(netId);
1219     dataParcel.WriteInt32(rangesSize);
1220     for (auto iter : uidRanges) {
1221         iter.Marshalling(dataParcel);
1222     }
1223 
1224     OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DEL_UIDS), dataParcel);
1225 }
1226 
LLVMFuzzerTestOneInputNew(const uint8_t * data,size_t size)1227 void LLVMFuzzerTestOneInputNew(const uint8_t *data, size_t size)
1228 {
1229     OHOS::NetManagerStandard::RegisterNotifyCallbackFuzzTest(data, size);
1230     OHOS::NetManagerStandard::UnRegisterNotifyCallbackFuzzTest(data, size);
1231     OHOS::NetManagerStandard::InterfaceSetIffUpFuzzTest(data, size);
1232     OHOS::NetManagerStandard::GetAddrInfoFuzzTest(data, size);
1233     OHOS::NetManagerStandard::NetworkAddRouteParcelFuzzTest(data, size);
1234     OHOS::NetManagerStandard::NetworkSetDefaultFuzzTest(data, size);
1235     OHOS::NetManagerStandard::NetworkGetDefaultFuzzTest(data, size);
1236     OHOS::NetManagerStandard::NetworkClearDefaultFuzzTest(data, size);
1237     OHOS::NetManagerStandard::GetProcSysNetFuzzTest(data, size);
1238     OHOS::NetManagerStandard::SetProcSysNetFuzzTest(data, size);
1239     OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1240     OHOS::NetManagerStandard::GetFwmarkForNetworkFuzzTest(data, size);
1241     OHOS::NetManagerStandard::IpEnableForwardingFuzzTest(data, size);
1242     OHOS::NetManagerStandard::IpDisableForwardingFuzzTest(data, size);
1243     OHOS::NetManagerStandard::EnableNatFuzzTest(data, size);
1244     OHOS::NetManagerStandard::DisableNatFuzzTest(data, size);
1245     OHOS::NetManagerStandard::BandwidthEnableDataSaverFuzzTest(data, size);
1246     OHOS::NetManagerStandard::BandwidthSetIfaceQuotaFuzzTest(data, size);
1247     OHOS::NetManagerStandard::BandwidthRemoveIfaceQuotaFuzzTest(data, size);
1248     OHOS::NetManagerStandard::BandwidthAddDeniedListFuzzTest(data, size);
1249     OHOS::NetManagerStandard::BandwidthRemoveDeniedListFuzzTest(data, size);
1250     OHOS::NetManagerStandard::BandwidthAddAllowedListFuzzTest(data, size);
1251     OHOS::NetManagerStandard::BandwidthRemoveAllowedListFuzzTest(data, size);
1252     OHOS::NetManagerStandard::FirewallEnableChainFuzzTest(data, size);
1253     OHOS::NetManagerStandard::GetNetworkSharingTrafficFuzzTest(data, size);
1254     OHOS::NetManagerStandard::NetworkCreateVirtualFuzzTest(data, size);
1255     OHOS::NetManagerStandard::NetworkAddUidsFuzzTest(data, size);
1256     OHOS::NetManagerStandard::NetworkDelUidsFuzzTest(data, size);
1257 }
1258 } // namespace NetManagerStandard
1259 } // namespace OHOS
1260 
1261 /* Fuzzer entry point1 */
1262 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1263 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1264 {
1265     /* Run your code on data */
1266     OHOS::NetManagerStandard::NetworkCreatePhysicalFuzzTest(data, size);
1267     OHOS::NetManagerStandard::NetworkDestroyFuzzTest(data, size);
1268     OHOS::NetManagerStandard::NetworkAddInterfaceFuzzTest(data, size);
1269     OHOS::NetManagerStandard::NetworkRemoveInterfaceFuzzTest(data, size);
1270     OHOS::NetManagerStandard::NetworkAddRouteFuzzTest(data, size);
1271     OHOS::NetManagerStandard::NetworkRemoveRouteFuzzTest(data, size);
1272     OHOS::NetManagerStandard::GetInterfaceConfigFuzzTest(data, size);
1273     OHOS::NetManagerStandard::GetInterfaceMtuFuzzTest(data, size);
1274     OHOS::NetManagerStandard::SetInterfaceMtuFuzzTest(data, size);
1275     OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1276     OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1277     OHOS::NetManagerStandard::SetResolverConfigFuzzTest(data, size);
1278     OHOS::NetManagerStandard::GetResolverConfigFuzzTest(data, size);
1279     OHOS::NetManagerStandard::DestroyNetworkCacheFuzzTest(data, size);
1280     OHOS::NetManagerStandard::InterfaceGetListFuzzTest(data, size);
1281     OHOS::NetManagerStandard::ShareDnsSetFuzzTest(data, size);
1282     OHOS::NetManagerStandard::StartDnsProxyListenFuzzTest(data, size);
1283     OHOS::NetManagerStandard::StopDnsProxyListenFuzzTest(data, size);
1284     OHOS::NetManagerStandard::StartDhcpClientFuzzTest(data, size);
1285     OHOS::NetManagerStandard::StopDhcpClientFuzzTest(data, size);
1286     OHOS::NetManagerStandard::StartDhcpServiceFuzzTest(data, size);
1287     OHOS::NetManagerStandard::StopDhcpServiceFuzzTest(data, size);
1288     OHOS::NetManagerStandard::SetIptablesCommandForResFuzzTest(data, size);
1289     OHOS::NetManagerStandard::SetDefaultNetWorkFuzzTest(data, size);
1290     OHOS::NetManagerStandard::SetInterfaceConfigFuzzTest(data, size);
1291     OHOS::NetManagerStandard::IpfwdAddInterfaceForwardFuzzTest(data, size);
1292     OHOS::NetManagerStandard::IpfwdRemoveInterfaceForwardFuzzTest(data, size);
1293     OHOS::NetManagerStandard::InterfaceSetIpAddressFuzzTest(data, size);
1294     OHOS::NetManagerStandard::FirewallSetUidsAllowedListChainFuzzTest(data, size);
1295     OHOS::NetManagerStandard::FirewallSetUidsDeniedListChainFuzzTest(data, size);
1296     OHOS::NetManagerStandard::FirewallSetUidRuleFuzzTest(data, size);
1297     OHOS::NetManagerStandard::LLVMFuzzerTestOneInputNew(data, size);
1298     return 0;
1299 }