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