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 "netshare_client_fuzzer.h"
17 
18 #include <cstddef>
19 #include <cstdint>
20 #include <iosfwd>
21 #include <memory>
22 #include <new>
23 #include <string>
24 
25 #include <securec.h>
26 
27 #include "refbase.h"
28 #include "singleton.h"
29 #ifdef WIFI_MODOULE
30 #include "wifi_ap_msg.h"
31 #endif
32 
33 #include "i_networkshare_service.h"
34 #include "interface_configuration.h"
35 #include "net_manager_ext_constants.h"
36 #include "netmanager_ext_test_security.h"
37 #include "netmgr_ext_log_wrapper.h"
38 #define private public
39 #include "networkshare_service.h"
40 
41 namespace OHOS {
42 namespace NetManagerStandard {
43 namespace {
44 const uint8_t *g_baseFuzzData = nullptr;
45 static constexpr uint32_t CREATE_SHARE_IFACE_TYPE_VALUE = 3;
46 static constexpr uint32_t CREATE_SHARE_IFACE_STATE_VALUE = 3;
47 static constexpr uint32_t ENUM_TYPE_VALUE3 = 3;
48 #ifdef BLUETOOTH_MODOULE
49 static constexpr uint32_t ENUM_TYPE_VALUE4 = 4;
50 #endif
51 static constexpr uint32_t ENUM_TYPE_VALUE5 = 5;
52 #ifdef WIFI_MODOULE
53 static constexpr uint32_t ENUM_TYPE_VALUE6 = 6;
54 #endif
55 static constexpr uint32_t ENUM_TYPE_BEGIN = 1;
56 static constexpr uint32_t LIMIT_RUN_NUMBER = 5;
57 size_t g_baseFuzzSize = 0;
58 size_t g_baseFuzzPos;
59 uint32_t g_testRunTimes = 0;
60 constexpr size_t IFACE_LEN = 5;
61 } // namespace
62 
GetData()63 template <class T> T GetData()
64 {
65     T object{};
66     size_t objectSize = sizeof(object);
67     if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
68         return object;
69     }
70     errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
71     if (ret != EOK) {
72         return {};
73     }
74     g_baseFuzzPos += objectSize;
75     return object;
76 }
77 
GetStringFromData(int strlen)78 std::string GetStringFromData(int strlen)
79 {
80     char cstr[strlen];
81     cstr[strlen - 1] = '\0';
82     for (int i = 0; i < strlen - 1; i++) {
83         cstr[i] = GetData<char>();
84     }
85     std::string str(cstr);
86     return str;
87 }
88 
InitGlobalData(const uint8_t * data,size_t size)89 bool InitGlobalData(const uint8_t *data, size_t size)
90 {
91     if (data == nullptr || size == 0) {
92         return false;
93     }
94     g_baseFuzzData = data;
95     g_baseFuzzSize = size;
96     g_baseFuzzPos = 0;
97     return true;
98 }
99 
100 class INetShareCallbackTest : public IRemoteStub<ISharingEventCallback> {
101 public:
OnSharingStateChanged(const bool & isRunning)102     void OnSharingStateChanged(const bool &isRunning)
103     {
104         return;
105     }
OnInterfaceSharingStateChanged(const SharingIfaceType & type,const std::string & iface,const SharingIfaceState & state)106     void OnInterfaceSharingStateChanged(const SharingIfaceType &type, const std::string &iface,
107                                         const SharingIfaceState &state)
108     {
109         return;
110     }
OnSharingUpstreamChanged(const sptr<NetHandle> netHandle)111     void OnSharingUpstreamChanged(const sptr<NetHandle> netHandle)
112     {
113         return;
114     }
115 };
116 
117 class SubStateMachineCallbackTest : public NetworkShareSubStateMachine::SubStateMachineCallback {
OnUpdateInterfaceState(const std::shared_ptr<NetworkShareSubStateMachine> & paraSubStateMachine,int state,int lastError)118     void OnUpdateInterfaceState(const std::shared_ptr<NetworkShareSubStateMachine> &paraSubStateMachine, int state,
119                                 int lastError)
120     {
121     }
122 };
123 
124 class NotifyUpstreamCallbackTest : public NetworkShareUpstreamMonitor::NotifyUpstreamCallback {
OnUpstreamStateChanged(int32_t msgName,int32_t param1)125     void OnUpstreamStateChanged(int32_t msgName, int32_t param1) {}
OnUpstreamStateChanged(int32_t msgName,int32_t param1,int32_t param2,const std::any & messageObj)126     void OnUpstreamStateChanged(int32_t msgName, int32_t param1, int32_t param2, const std::any &messageObj) {}
127 };
128 
129 static bool g_isInited = false;
Init()130 void Init()
131 {
132     if (!g_isInited) {
133         DelayedSingleton<NetworkShareService>::GetInstance()->Init();
134         g_isInited = true;
135     }
136 }
137 
OnRemoteRequest(TetheringInterfaceCode code,MessageParcel & data)138 __attribute__((no_sanitize("cfi"))) int32_t OnRemoteRequest(TetheringInterfaceCode code, MessageParcel &data)
139 {
140     if (!g_isInited) {
141         Init();
142     }
143 
144     MessageParcel reply;
145     MessageOption option;
146 
147     return DelayedSingleton<NetworkShareService>::GetInstance()->OnRemoteRequest(static_cast<uint32_t>(code), data,
148                                                                                  reply, option);
149 }
150 
WriteInterfaceToken(MessageParcel & data)151 bool WriteInterfaceToken(MessageParcel &data)
152 {
153     if (!data.WriteInterfaceToken(NetworkShareServiceStub::GetDescriptor())) {
154         return false;
155     }
156     return true;
157 }
158 
GetMessageParcel(const uint8_t * data,size_t size,MessageParcel & dataParcel)159 bool GetMessageParcel(const uint8_t *data, size_t size, MessageParcel &dataParcel)
160 {
161     if (!InitGlobalData(data, size)) {
162         return false;
163     }
164 
165     NetManagerExtAccessToken token;
166 
167     if (!WriteInterfaceToken(dataParcel)) {
168         return false;
169     }
170     int32_t type = GetData<int32_t>() % CREATE_SHARE_IFACE_TYPE_VALUE;
171     dataParcel.WriteInt32(type);
172 
173     return true;
174 }
175 
IsNetworkSharingSupportedFuzzTest(const uint8_t * data,size_t size)176 void IsNetworkSharingSupportedFuzzTest(const uint8_t *data, size_t size)
177 {
178     NETMGR_EXT_LOG_D("IsNetworkSharingSupportedFuzzTest enter");
179     if (!InitGlobalData(data, size)) {
180         return;
181     }
182     NetManagerExtAccessToken token;
183 
184     MessageParcel dataParcel;
185     if (!WriteInterfaceToken(dataParcel)) {
186         return;
187     }
188 
189     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_SHARING_SUPPORTED, dataParcel);
190 }
191 
IsSharingFuzzTest(const uint8_t * data,size_t size)192 void IsSharingFuzzTest(const uint8_t *data, size_t size)
193 {
194     NETMGR_EXT_LOG_D("IsSharingFuzzTest enter");
195     if (!InitGlobalData(data, size)) {
196         return;
197     }
198 
199     NetManagerExtAccessToken token;
200 
201     MessageParcel dataParcel;
202     if (!WriteInterfaceToken(dataParcel)) {
203         return;
204     }
205 
206     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_IS_SHARING, dataParcel);
207 }
208 
StartNetworkSharingFuzzTest(const uint8_t * data,size_t size)209 void StartNetworkSharingFuzzTest(const uint8_t *data, size_t size)
210 {
211     NETMGR_EXT_LOG_D("StartNetworkSharingFuzzTest enter");
212 
213     MessageParcel dataParcel;
214     if (!GetMessageParcel(data, size, dataParcel)) {
215         return;
216     }
217 
218     OnRemoteRequest(TetheringInterfaceCode::CMD_START_NETWORKSHARE, dataParcel);
219 }
220 
StopNetworkSharingFuzzTest(const uint8_t * data,size_t size)221 void StopNetworkSharingFuzzTest(const uint8_t *data, size_t size)
222 {
223     NETMGR_EXT_LOG_D("StopNetworkSharingFuzzTest enter");
224     MessageParcel dataParcel;
225     if (!GetMessageParcel(data, size, dataParcel)) {
226         return;
227     }
228     OnRemoteRequest(TetheringInterfaceCode::CMD_STOP_NETWORKSHARE, dataParcel);
229 }
230 
GetSharableRegexsFuzzTest(const uint8_t * data,size_t size)231 void GetSharableRegexsFuzzTest(const uint8_t *data, size_t size)
232 {
233     NETMGR_EXT_LOG_D("GetSharableRegexsFuzzTest enter");
234     MessageParcel dataParcel;
235     if (!GetMessageParcel(data, size, dataParcel)) {
236         return;
237     }
238     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_SHARABLE_REGEXS, dataParcel);
239 }
240 
GetSharingStateFuzzTest(const uint8_t * data,size_t size)241 void GetSharingStateFuzzTest(const uint8_t *data, size_t size)
242 {
243     NETMGR_EXT_LOG_D("GetSharingStateFuzzTest enter");
244     MessageParcel dataParcel;
245     if (!GetMessageParcel(data, size, dataParcel)) {
246         return;
247     }
248     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_SHARING_STATE, dataParcel);
249 }
250 
GetNetSharingIfacesFuzzTest(const uint8_t * data,size_t size)251 void GetNetSharingIfacesFuzzTest(const uint8_t *data, size_t size)
252 {
253     NETMGR_EXT_LOG_D("GetNetSharingIfacesFuzzTest enter");
254     if (!InitGlobalData(data, size)) {
255         return;
256     }
257 
258     NetManagerExtAccessToken token;
259 
260     MessageParcel dataParcel;
261     if (!WriteInterfaceToken(dataParcel)) {
262         return;
263     }
264     uint32_t state = GetData<int32_t>() % CREATE_SHARE_IFACE_STATE_VALUE + ENUM_TYPE_BEGIN;
265     dataParcel.WriteInt32(state);
266     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_SHARING_IFACES, dataParcel);
267 }
268 
RegisterSharingEventFuzzTest(const uint8_t * data,size_t size)269 void RegisterSharingEventFuzzTest(const uint8_t *data, size_t size)
270 {
271     NETMGR_EXT_LOG_D("RegisterSharingEventFuzzTest enter");
272     if (!InitGlobalData(data, size)) {
273         return;
274     }
275 
276     NetManagerExtAccessToken token;
277 
278     sptr<ISharingEventCallback> callback = new (std::nothrow) INetShareCallbackTest();
279     MessageParcel dataParcel;
280     if (!WriteInterfaceToken(dataParcel)) {
281         return;
282     }
283     dataParcel.WriteRemoteObject(callback->AsObject());
284     OnRemoteRequest(TetheringInterfaceCode::CMD_REGISTER_EVENT_CALLBACK, dataParcel);
285 }
286 
UnregisterSharingEventFuzzTest(const uint8_t * data,size_t size)287 void UnregisterSharingEventFuzzTest(const uint8_t *data, size_t size)
288 {
289     NETMGR_EXT_LOG_D("UnregisterSharingEventFuzzTest enter");
290     if (!InitGlobalData(data, size)) {
291         return;
292     }
293 
294     NetManagerExtAccessToken token;
295 
296     sptr<ISharingEventCallback> callback = new (std::nothrow) INetShareCallbackTest();
297     MessageParcel dataParcel;
298     if (!WriteInterfaceToken(dataParcel)) {
299         return;
300     }
301     dataParcel.WriteRemoteObject(callback->AsObject());
302     OnRemoteRequest(TetheringInterfaceCode::CMD_UNREGISTER_EVENT_CALLBACK, dataParcel);
303 }
304 
GetStatsRxBytesFuzzTest(const uint8_t * data,size_t size)305 void GetStatsRxBytesFuzzTest(const uint8_t *data, size_t size)
306 {
307     NETMGR_EXT_LOG_D("GetStatsRxBytesFuzzTest enter");
308     if (!InitGlobalData(data, size)) {
309         return;
310     }
311 
312     NetManagerExtAccessToken token;
313 
314     MessageParcel dataParcel;
315     if (!WriteInterfaceToken(dataParcel)) {
316         return;
317     }
318     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_RX_BYTES, dataParcel);
319 }
320 
GetStatsTxBytesFuzzTest(const uint8_t * data,size_t size)321 void GetStatsTxBytesFuzzTest(const uint8_t *data, size_t size)
322 {
323     NETMGR_EXT_LOG_D("GetStatsTxBytesFuzzTest enter");
324     if (!InitGlobalData(data, size)) {
325         return;
326     }
327 
328     NetManagerExtAccessToken token;
329 
330     MessageParcel dataParcel;
331     if (!WriteInterfaceToken(dataParcel)) {
332         return;
333     }
334     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_TX_BYTES, dataParcel);
335 }
336 
GetStatsTotalBytesFuzzTest(const uint8_t * data,size_t size)337 void GetStatsTotalBytesFuzzTest(const uint8_t *data, size_t size)
338 {
339     NETMGR_EXT_LOG_D("GetStatsTotalBytesFuzzTest enter");
340     if (!InitGlobalData(data, size)) {
341         return;
342     }
343 
344     NetManagerExtAccessToken token;
345 
346     MessageParcel dataParcel;
347     if (!WriteInterfaceToken(dataParcel)) {
348         return;
349     }
350     OnRemoteRequest(TetheringInterfaceCode::CMD_GET_TOTAL_BYTES, dataParcel);
351 }
352 
NetGetStatsBytesFuzzTest(const uint8_t * data,size_t size)353 void NetGetStatsBytesFuzzTest(const uint8_t *data, size_t size)
354 {
355     if (g_testRunTimes < LIMIT_RUN_NUMBER) {
356         GetStatsRxBytesFuzzTest(data, size);
357         GetStatsTxBytesFuzzTest(data, size);
358         GetStatsTotalBytesFuzzTest(data, size);
359     }
360 }
361 
NetworkShareMainStateMachineFuzzTest(const uint8_t * data,size_t size)362 __attribute__((no_sanitize("cfi"))) void NetworkShareMainStateMachineFuzzTest(const uint8_t *data, size_t size)
363 {
364     NETMGR_EXT_LOG_D("NetworkShareMainStateMachineFuzzTest enter");
365     if (!InitGlobalData(data, size)) {
366         return;
367     }
368 
369     std::shared_ptr<NetworkShareUpstreamMonitor> networkmonitor =
370         NetworkShareUpstreamMonitor::GetInstance();
371 
372     auto networkShareMainStateMachine = std::make_unique<NetworkShareMainStateMachine>(networkmonitor);
373     int32_t errType = GetData<int32_t>();
374     networkShareMainStateMachine->SwitcheToErrorState(errType);
375     int32_t newState = GetData<int32_t>();
376     networkShareMainStateMachine->MainSmStateSwitch(newState);
377     int32_t anyNum = GetData<int32_t>();
378     networkShareMainStateMachine->TurnOnMainShareSettings();
379     networkShareMainStateMachine->TurnOffMainShareSettings();
380     MessageIfaceActive messageIfaceActive;
381     messageIfaceActive.value_ = anyNum;
382     networkShareMainStateMachine->HandleInitInterfaceStateActive(messageIfaceActive);
383     networkShareMainStateMachine->HandleInitInterfaceStateInactive(messageIfaceActive);
384     auto networkShareMainStateMachine1 = std::make_unique<NetworkShareMainStateMachine>(networkmonitor);
385     networkShareMainStateMachine1->HandleAliveInterfaceStateActive(messageIfaceActive);
386     networkShareMainStateMachine1->HandleAliveInterfaceStateInactive(messageIfaceActive);
387     MessageUpstreamInfo upstreamNetInfo;
388     upstreamNetInfo.cmd_ = anyNum;
389     auto networkShareMainStateMachine3 = std::make_unique<NetworkShareMainStateMachine>(networkmonitor);
390     networkShareMainStateMachine3->HandleAliveUpstreamMonitorCallback(upstreamNetInfo);
391     networkShareMainStateMachine3->HandleErrorInterfaceStateInactive(messageIfaceActive);
392     networkShareMainStateMachine3->HandleErrorClear(upstreamNetInfo);
393     auto networkShareMainStateMachine2 = std::make_unique<NetworkShareMainStateMachine>(networkmonitor);
394     networkShareMainStateMachine2->InitStateEnter();
395     networkShareMainStateMachine2->AliveStateEnter();
396     networkShareMainStateMachine2->ErrorStateEnter();
397     networkShareMainStateMachine2->InitStateExit();
398     networkShareMainStateMachine2->AliveStateExit();
399     networkShareMainStateMachine2->ErrorStateExit();
400     networkShareMainStateMachine2->ChooseUpstreamNetwork();
401     networkShareMainStateMachine2->DisableForward();
402     networkShareMainStateMachine2->EraseSharedSubSM(messageIfaceActive);
403 }
404 
NetworkShareSubStateMachineFuzzTest(const uint8_t * data,size_t size)405 void NetworkShareSubStateMachineFuzzTest(const uint8_t *data, size_t size)
406 {
407     NETMGR_EXT_LOG_D("NetworkShareSubStateMachineFuzzTest enter");
408     if (!InitGlobalData(data, size)) {
409         return;
410     }
411 
412     std::shared_ptr<NetworkShareConfiguration> configuration;
413     std::string ifaceName = GetStringFromData(IFACE_LEN);
414     SharingIfaceType interfaceType = static_cast<SharingIfaceType>(GetData<uint32_t>() % CREATE_SHARE_IFACE_TYPE_VALUE);
415     auto networkShareSubStateMachine =
416         std::make_unique<NetworkShareSubStateMachine>(ifaceName, interfaceType, configuration);
417 
418     networkShareSubStateMachine->GetNetShareType();
419     networkShareSubStateMachine->GetInterfaceName();
420     int32_t newState = GetData<int32_t>();
421     networkShareSubStateMachine->SubSmStateSwitch(newState);
422     std::string downIface = GetStringFromData(IFACE_LEN);
423     networkShareSubStateMachine->GetDownIfaceName(downIface);
424     std::string upIface = GetStringFromData(IFACE_LEN);
425     int32_t num = GetData<int32_t>();
426     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle(num);
427     sptr<NetAllCapabilities> netcap = new (std::nothrow) NetManagerStandard::NetAllCapabilities();
428     sptr<NetLinkInfo> netlinkinfo = new (std::nothrow) NetManagerStandard::NetLinkInfo();
429     networkShareSubStateMachine->GetUpIfaceName(upIface);
430 }
431 
DonetworkShareSubStateMachine(std::unique_ptr<NetworkShareSubStateMachine> & networkShareSubStateMachine,std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo,std::shared_ptr<INetAddr> addr,std::string str)432 void DonetworkShareSubStateMachine(std::unique_ptr<NetworkShareSubStateMachine> &networkShareSubStateMachine,
433                                    std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo,
434                                    std::shared_ptr<INetAddr> addr,
435                                    std::string str)
436 {
437     networkShareSubStateMachine->CreateInitStateTable();
438     networkShareSubStateMachine->CreateSharedStateTable();
439     networkShareSubStateMachine->InitStateEnter();
440     networkShareSubStateMachine->SharedStateEnter();
441     networkShareSubStateMachine->UnavailableStateEnter();
442     networkShareSubStateMachine->InitStateExit();
443     networkShareSubStateMachine->SharedStateExit();
444     networkShareSubStateMachine->UnavailableStateExit();
445     networkShareSubStateMachine->HandleInitSharingRequest(upstreamNetInfo);
446     networkShareSubStateMachine->HandleInitInterfaceDown(upstreamNetInfo);
447     networkShareSubStateMachine->HandleSharedUnrequest(upstreamNetInfo);
448     networkShareSubStateMachine->HandleSharedInterfaceDown(upstreamNetInfo);
449     networkShareSubStateMachine->HandleSharedConnectionChange(upstreamNetInfo);
450     networkShareSubStateMachine->HandleSharedErrors(upstreamNetInfo);
451     networkShareSubStateMachine->ConfigureShareDhcp(GetData<int32_t>() > 0);
452     networkShareSubStateMachine->RequestIpv4Address(addr);
453     networkShareSubStateMachine->StartDhcp(addr);
454     networkShareSubStateMachine->StopDhcp();
455     networkShareSubStateMachine->AddIpv6AddrToLocalNetwork();
456     networkShareSubStateMachine->AddIpv6InfoToLocalNetwork();
457     networkShareSubStateMachine->StartIpv6();
458     networkShareSubStateMachine->StopIpv6();
459     networkShareSubStateMachine->HandleConnectionChanged(upstreamNetInfo);
460     networkShareSubStateMachine->HandleConnection();
461     networkShareSubStateMachine->RemoveRoutesToLocalNetwork();
462     networkShareSubStateMachine->AddRoutesToLocalNetwork();
463     networkShareSubStateMachine->CleanupUpstreamInterface();
464     networkShareSubStateMachine->HasChangeUpstreamIfaceSet(str);
465     networkShareSubStateMachine->GetWifiHotspotDhcpFlag();
466     networkShareSubStateMachine->GetBtDestinationAddr(str);
467     networkShareSubStateMachine->GetWifiApDestinationAddr(str);
468     networkShareSubStateMachine->GetUsbDestinationAddr(str);
469     networkShareSubStateMachine->CheckConfig(str, str);
470     networkShareSubStateMachine->FindDestinationAddr(str);
471 }
472 
NetworkShareSubStateMachinePrivateFuzzTest(const uint8_t * data,size_t size)473 void NetworkShareSubStateMachinePrivateFuzzTest(const uint8_t *data, size_t size)
474 {
475     NETMGR_EXT_LOG_D("NetworkShareSubStateMachinePrivateFuzzTest enter");
476     if (!InitGlobalData(data, size)) {
477         return;
478     }
479     std::shared_ptr<NetworkShareConfiguration> config;
480     std::string str = GetStringFromData(IFACE_LEN);
481     SharingIfaceType interfaceType = static_cast<SharingIfaceType>(GetData<uint32_t>() % CREATE_SHARE_IFACE_TYPE_VALUE);
482     auto networkShareSubStateMachine = std::make_unique<NetworkShareSubStateMachine>(str, interfaceType, config);
483     sptr<NetHandle> handle = new (std::nothrow) NetHandle(GetData<int32_t>());
484     sptr<NetAllCapabilities> netcap = new (std::nothrow) NetManagerStandard::NetAllCapabilities();
485     sptr<NetLinkInfo> link = new (std::nothrow) NetManagerStandard::NetLinkInfo();
486     std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo = std::make_shared<UpstreamNetworkInfo>(handle, netcap, link);
487     std::shared_ptr<INetAddr> addr = std::make_shared<INetAddr>();
488     addr->family_ = GetData<int8_t>();
489     addr->prefixlen_ = GetData<int8_t>();
490     addr->address_ = str;
491     addr->netMask_ = str;
492     addr->hostName_ = str;
493     addr->port_ = GetData<int8_t>();
494     DonetworkShareSubStateMachine(networkShareSubStateMachine, upstreamNetInfo, addr, str);
495 }
496 
UpstreammonitorFuzzTest(const uint8_t * data,size_t size)497 void UpstreammonitorFuzzTest(const uint8_t *data, size_t size)
498 {
499     NETMGR_EXT_LOG_D("UpstreammonitorFuzzTest enter");
500     if (!InitGlobalData(data, size)) {
501         return;
502     }
503 
504     int32_t num = GetData<int32_t>();
505     std::shared_ptr<NetworkShareUpstreamMonitor> networkmonitor =
506         NetworkShareUpstreamMonitor::GetInstance();
507 
508     networkmonitor->ListenDefaultNetwork();
509     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle(num);
510     sptr<NetAllCapabilities> netcap = new (std::nothrow) NetManagerStandard::NetAllCapabilities();
511     sptr<NetLinkInfo> netlinkinfo = new (std::nothrow) NetManagerStandard::NetLinkInfo();
512     std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo =
513         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
514     networkmonitor->GetCurrentGoodUpstream(upstreamNetInfo);
515 
516     networkmonitor->NotifyMainStateMachine(num, upstreamNetInfo);
517     networkmonitor->NotifyMainStateMachine(num);
518     networkmonitor->HandleNetAvailable(netHandle);
519     networkmonitor->HandleNetCapabilitiesChange(netHandle, netcap);
520     networkmonitor->HandleConnectionPropertiesChange(netHandle, netlinkinfo);
521     networkmonitor->HandleNetLost(netHandle);
522 }
523 
NetworkShareTrackerFuzzTest(const uint8_t * data,size_t size)524 void NetworkShareTrackerFuzzTest(const uint8_t *data, size_t size)
525 {
526     NETMGR_EXT_LOG_D("NetworkShareTrackerFuzzTest enter");
527     if (!InitGlobalData(data, size)) {
528         return;
529     }
530 
531     int32_t num = GetData<int32_t>();
532     std::string iface = GetStringFromData(IFACE_LEN);
533     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle(num);
534     sptr<NetAllCapabilities> netcap = new (std::nothrow) NetManagerStandard::NetAllCapabilities();
535     sptr<NetLinkInfo> netlinkinfo = new (std::nothrow) NetManagerStandard::NetLinkInfo();
536     SharingIfaceType ifaceType = SharingIfaceType(SharingIfaceType(num % ENUM_TYPE_VALUE3));
537     SharingIfaceState ifaceState = SharingIfaceState((num % ENUM_TYPE_VALUE3) + ENUM_TYPE_BEGIN);
538     TrafficType trafficTYpe = TrafficType((num % ENUM_TYPE_VALUE3) + ENUM_TYPE_BEGIN);
539     int32_t supported = 0;
540     int32_t sharingStatus = 0;
541     std::vector<std::string> ifaceRegexs;
542     std::vector<std::string> ifaces;
543     int32_t kbByte = 0;
544     NetworkShareTracker::GetInstance().Uninit();
545     NetworkShareTracker::GetInstance().IsNetworkSharingSupported(supported);
546     NetworkShareTracker::GetInstance().IsSharing(sharingStatus);
547     NetworkShareTracker::GetInstance().StartNetworkSharing(ifaceType);
548     NetworkShareTracker::GetInstance().StopNetworkSharing(ifaceType);
549     NetworkShareTracker::GetInstance().GetSharableRegexs(ifaceType, ifaceRegexs);
550     NetworkShareTracker::GetInstance().GetSharingState(ifaceType, ifaceState);
551     NetworkShareTracker::GetInstance().GetNetSharingIfaces(ifaceState, ifaces);
552     sptr<INetShareCallbackTest> callback = new (std::nothrow) INetShareCallbackTest();
553     NetworkShareTracker::GetInstance().RegisterSharingEvent(callback);
554     NetworkShareTracker::GetInstance().UnregisterSharingEvent(callback);
555     NetworkShareTracker::GetInstance().UpstreamWanted();
556     std::shared_ptr<NetworkShareSubStateMachine> subSm =
557         std::make_shared<NetworkShareSubStateMachine>(iface, ifaceType, nullptr);
558     NetworkShareTracker::GetInstance().ModifySharedSubStateMachineList(num > 0, subSm);
559     NetworkShareTracker::GetInstance().GetMainStateMachine();
560     std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo =
561         std::make_shared<UpstreamNetworkInfo>(netHandle, netcap, netlinkinfo);
562     NetworkShareTracker::GetInstance().SetUpstreamNetHandle(upstreamNetInfo);
563     NetworkShareTracker::GetInstance().GetUpstreamInfo(upstreamNetInfo);
564     NetworkShareTracker::GetInstance().NotifyDownstreamsHasNewUpstreamIface(upstreamNetInfo);
565     /*
566      * There will be operations of the fork process here, and it is necessary to limit the number of runs. Otherwise,
567      * frequent high-speed calls to the FUZZ test case will cause insufficient resources and lead to downtime.
568      */
569     if (g_testRunTimes < LIMIT_RUN_NUMBER) {
570         NetworkShareTracker::GetInstance().GetSharedSubSMTraffic(trafficTYpe, kbByte);
571         g_testRunTimes++;
572     }
573 }
574 
NetworkShareTrackerPrivateFuzzTest(const uint8_t * data,size_t size)575 void NetworkShareTrackerPrivateFuzzTest(const uint8_t *data, size_t size)
576 {
577     NETMGR_EXT_LOG_D("NetworkShareTrackerPrivateFuzzTest enter");
578     if (!InitGlobalData(data, size)) {
579         return;
580     }
581 
582     int32_t num = GetData<int32_t>();
583     std::string iface = GetStringFromData(IFACE_LEN);
584     sptr<NetHandle> netHandle = new (std::nothrow) NetHandle(num);
585     SharingIfaceType ifaceType = SharingIfaceType(SharingIfaceType(num % ENUM_TYPE_VALUE3));
586     std::shared_ptr<NetworkShareSubStateMachine> subSm =
587         std::make_shared<NetworkShareSubStateMachine>(iface, ifaceType, nullptr);
588     SharingIfaceState ifaceState = SharingIfaceState((num % ENUM_TYPE_VALUE3) + ENUM_TYPE_BEGIN);
589 
590     auto &tra = NetworkShareTracker::GetInstance();
591     tra.HandleSubSmUpdateInterfaceState(subSm, num, num);
592     tra.EnableNetSharingInternal(ifaceType, num > 0);
593     tra.SetWifiNetworkSharing(num > 0);
594 #ifdef USB_MODOULE
595     tra.SetUsbNetworkSharing(num > 0);
596 #endif
597     tra.SetBluetoothNetworkSharing(num > 0);
598     tra.EnableWifiSubStateMachine();
599     tra.EnableBluetoothSubStateMachine();
600     tra.Sharing(iface, num);
601     tra.SendGlobalSharingStateChange();
602     tra.SendIfaceSharingStateChange(ifaceType, iface, ifaceState);
603     tra.SendSharingUpstreamChange(netHandle);
604     tra.CreateSubStateMachine(iface, ifaceType, num > 0);
605     tra.StopSubStateMachine(iface, ifaceType);
606     tra.IsInterfaceMatchType(iface, ifaceType);
607     tra.InterfaceNameToType(iface, ifaceType);
608     tra.IsHandleNetlinkEvent(ifaceType, num > 0);
609     tra.FindSubStateMachine(iface, ifaceType, subSm, iface);
610     tra.InterfaceAdded(iface);
611     tra.InterfaceRemoved(iface);
612     tra.InterfaceStatusChanged(iface, num > 0);
613     tra.SetDnsForwarders(*netHandle);
614     tra.StopDnsProxy();
615     tra.SubSmStateToExportState(num);
616     tra.RegisterWifiApCallback();
617     tra.RegisterBtPanCallback();
618 #ifdef WIFI_MODOULE
619     tra.SetWifiState(Wifi::ApState(num % ENUM_TYPE_VALUE6));
620 #endif
621 #ifdef BLUETOOTH_MODOULE
622     tra.SetBluetoothState(Bluetooth::BTConnectState(num % ENUM_TYPE_VALUE4));
623 #endif
624     tra.SendMainSMEvent(subSm, num, num);
625 }
626 
NetworkShareHisysEventFuzzTest(const uint8_t * data,size_t size)627 void NetworkShareHisysEventFuzzTest(const uint8_t *data, size_t size)
628 {
629     NETMGR_EXT_LOG_D("NetworkShareHisysEventFuzzTest enter");
630     if (!InitGlobalData(data, size)) {
631         return;
632     }
633 
634     int32_t num = GetData<int32_t>();
635     std::string str = GetStringFromData(IFACE_LEN);
636     SharingIfaceType ifaceType = SharingIfaceType(SharingIfaceType(num % ENUM_TYPE_VALUE3));
637     NetworkShareEventType eventType = NetworkShareEventType(num % ENUM_TYPE_VALUE3);
638     NetworkShareEventOperator eventOper = NetworkShareEventOperator(num % ENUM_TYPE_VALUE5);
639     auto &hisys = NetworkShareHisysEvent::GetInstance();
640     hisys.SendFaultEvent(eventOper, NetworkShareEventErrorType::ERROR_CANCEL_FORWARD, str, eventType);
641     hisys.SendFaultEvent(ifaceType, eventOper, NetworkShareEventErrorType::ERROR_CANCEL_FORWARD, str, eventType);
642     hisys.SendBehaviorEvent(num, ifaceType);
643 }
644 
NetworkShareConfigurationFuzzTest(const uint8_t * data,size_t size)645 void NetworkShareConfigurationFuzzTest(const uint8_t *data, size_t size)
646 {
647     NETMGR_EXT_LOG_D("NetworkShareConfigurationFuzzTest enter");
648     if (!InitGlobalData(data, size)) {
649         return;
650     }
651 
652     std::string str = GetStringFromData(IFACE_LEN);
653     std::vector<std::string> match = {"wlan", "softap", "usb"};
654 
655     NetworkShareConfiguration config;
656     config.IsNetworkSharingSupported();
657     config.IsUsbIface(str);
658     config.IsWifiIface(str);
659     config.IsBluetoothIface(str);
660     config.GetUsbIfaceRegexs();
661     config.GetWifiIfaceRegexs();
662     config.GetBluetoothIfaceRegexs();
663     config.GetWifiHotspotSetDhcpFlag();
664     config.GetBtpanIpv4Addr();
665     config.GetWifiHotspotIpv4Addr();
666     config.GetUsbRndisIpv4Addr();
667     config.GetRouteSuffix();
668     config.GetBtpanDhcpServerName();
669     config.GetWifiHotspotDhcpServerName();
670     config.GetUsbRndisDhcpServerName();
671     config.GetDefaultMask();
672     config.GetDhcpEndIP();
673 
674     config.LoadConfigData();
675     config.MatchesDownstreamRegexs(str, match);
676     config.ReadConfigFile();
677     config.ParseLineData(str, str);
678     std::vector<std::string> res;
679     config.ParseRegexsData(res, str);
680 }
681 } // namespace NetManagerStandard
682 } // namespace OHOS
683 
684 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)685 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
686 {
687     /* Run your code on data */
688     OHOS::NetManagerStandard::IsNetworkSharingSupportedFuzzTest(data, size);
689     OHOS::NetManagerStandard::IsSharingFuzzTest(data, size);
690     OHOS::NetManagerStandard::StartNetworkSharingFuzzTest(data, size);
691     OHOS::NetManagerStandard::StopNetworkSharingFuzzTest(data, size);
692     OHOS::NetManagerStandard::GetSharableRegexsFuzzTest(data, size);
693     OHOS::NetManagerStandard::GetSharingStateFuzzTest(data, size);
694     OHOS::NetManagerStandard::GetNetSharingIfacesFuzzTest(data, size);
695     OHOS::NetManagerStandard::RegisterSharingEventFuzzTest(data, size);
696     OHOS::NetManagerStandard::UnregisterSharingEventFuzzTest(data, size);
697     OHOS::NetManagerStandard::NetworkShareConfigurationFuzzTest(data, size);
698     OHOS::NetManagerStandard::UpstreammonitorFuzzTest(data, size);
699     OHOS::NetManagerStandard::NetworkShareTrackerFuzzTest(data, size);
700     OHOS::NetManagerStandard::NetworkShareTrackerPrivateFuzzTest(data, size);
701     OHOS::NetManagerStandard::NetworkShareSubStateMachineFuzzTest(data, size);
702     OHOS::NetManagerStandard::NetworkShareSubStateMachinePrivateFuzzTest(data, size);
703     OHOS::NetManagerStandard::NetworkShareMainStateMachineFuzzTest(data, size);
704     OHOS::NetManagerStandard::NetworkShareHisysEventFuzzTest(data, size);
705     OHOS::NetManagerStandard::NetGetStatsBytesFuzzTest(data, size);
706     return 0;
707 }
708