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