1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <securec.h>
17 #include <thread>
18 
19 #include "i_net_policy_service.h"
20 #include "net_mgr_log_wrapper.h"
21 #include "net_policy_client.h"
22 #include "net_policy_constants.h"
23 #include "net_quota_policy.h"
24 #include "netmanager_base_test_security.h"
25 #define private public
26 #include "net_policy_service.h"
27 #include "net_policy_service_stub.h"
28 
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 const uint8_t *g_baseFuzzData = nullptr;
33 static constexpr uint32_t CREATE_LIMIT_ACTION_VALUE = 2;
34 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
35 static constexpr uint32_t CONVERT_NUMBER_TO_BOOL = 2;
36 size_t g_baseFuzzSize = 0;
37 size_t g_baseFuzzPos;
38 constexpr size_t STR_LEN = 10;
39 } // namespace
40 
41 template<class T>
NetPolicyGetData()42 T NetPolicyGetData()
43 {
44     T object {};
45     size_t netPolicySize = sizeof(object);
46     if (g_baseFuzzData == nullptr || netPolicySize > g_baseFuzzSize - g_baseFuzzPos) {
47         return object;
48     }
49     errno_t ret = memcpy_s(&object, netPolicySize, g_baseFuzzData + g_baseFuzzPos, netPolicySize);
50     if (ret != EOK) {
51         return {};
52     }
53     g_baseFuzzPos += netPolicySize;
54     return object;
55 }
56 
NetPolicyGetString(int strlen)57 std::string NetPolicyGetString(int strlen)
58 {
59     char cstr[strlen];
60     cstr[strlen - 1] = '\0';
61     for (int i = 0; i < strlen - 1; i++) {
62         cstr[i] = NetPolicyGetData<char>();
63     }
64     std::string str(cstr);
65     return str;
66 }
67 
68 class INetPolicyCallbackTest : public IRemoteStub<INetPolicyCallback> {
69 public:
NetUidPolicyChange(uint32_t uid,uint32_t policy)70     int32_t NetUidPolicyChange(uint32_t uid, uint32_t policy)
71     {
72         return 0;
73     }
74 
NetUidRuleChange(uint32_t uid,uint32_t rule)75     int32_t NetUidRuleChange(uint32_t uid, uint32_t rule)
76     {
77         return 0;
78     }
79 
NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> & quotaPolicies)80     int32_t NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> &quotaPolicies)
81     {
82         return 0;
83     }
84 
NetStrategySwitch(const std::string & simId,bool enable)85     int32_t NetStrategySwitch(const std::string &simId, bool enable)
86     {
87         return 0;
88     }
89 
NetMeteredIfacesChange(std::vector<std::string> & ifaces)90     int32_t NetMeteredIfacesChange(std::vector<std::string> &ifaces)
91     {
92         return 0;
93     }
94 
NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)95     int32_t NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)
96     {
97         return 0;
98     }
99 };
100 
101 static bool g_isInited = false;
102 
Init()103 void Init()
104 {
105     if (!g_isInited) {
106         DelayedSingleton<NetPolicyService>::GetInstance()->Init();
107         g_isInited = true;
108     }
109 }
110 
OnRemoteRequest(uint32_t code,MessageParcel & data)111 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
112 {
113     if (!g_isInited) {
114         Init();
115     }
116 
117     MessageParcel reply;
118     MessageOption option;
119 
120     return DelayedSingleton<NetPolicyService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
121 }
122 
WriteInterfaceToken(MessageParcel & data)123 bool WriteInterfaceToken(MessageParcel &data)
124 {
125     if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
126         return false;
127     }
128     return true;
129 }
130 
IsValidPolicyFuzzData(const uint8_t * data,size_t size,MessageParcel & dataParcel)131 bool IsValidPolicyFuzzData(const uint8_t *data, size_t size, MessageParcel &dataParcel)
132 {
133     if ((data == nullptr) || (size == 0)) {
134         return false;
135     }
136 
137     g_baseFuzzData = data;
138     g_baseFuzzSize = size;
139     g_baseFuzzPos = 0;
140 
141     if (!WriteInterfaceToken(dataParcel)) {
142         return false;
143     }
144     return true;
145 }
146 
SetPolicyByUidFuzzTest(const uint8_t * data,size_t size)147 void SetPolicyByUidFuzzTest(const uint8_t *data, size_t size)
148 {
149     NetManagerBaseAccessToken token;
150     MessageParcel dataParcel;
151     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
152         return;
153     }
154 
155     uint32_t uid = NetPolicyGetData<uint32_t>();
156     uint32_t policy = NetPolicyGetData<uint32_t>() % 3;
157     dataParcel.WriteUint32(uid);
158     dataParcel.WriteUint32(policy);
159 
160     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID), dataParcel);
161 }
162 
GetPolicyByUidFuzzTest(const uint8_t * data,size_t size)163 void GetPolicyByUidFuzzTest(const uint8_t *data, size_t size)
164 {
165     NetManagerBaseAccessToken token;
166     uint32_t uid = NetPolicyGetData<uint32_t>();
167 
168     MessageParcel dataParcel;
169     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
170         return;
171     }
172     dataParcel.WriteUint32(uid);
173 
174     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID), dataParcel);
175 }
176 
GetUidsByPolicyFuzzTest(const uint8_t * data,size_t size)177 void GetUidsByPolicyFuzzTest(const uint8_t *data, size_t size)
178 {
179     NetManagerBaseAccessToken token;
180 
181     MessageParcel dataParcel;
182     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
183         return;
184     }
185     uint32_t policy = NetPolicyGetData<uint32_t>() % 3;
186     dataParcel.WriteUint32(policy);
187 
188     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY), dataParcel);
189 }
190 
SetBackgroundPolicyFuzzTest(const uint8_t * data,size_t size)191 void SetBackgroundPolicyFuzzTest(const uint8_t *data, size_t size)
192 {
193     NetManagerBaseAccessToken token;
194     bool isBackgroundPolicyAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
195 
196     MessageParcel dataParcel;
197     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
198         return;
199     }
200     dataParcel.WriteBool(isBackgroundPolicyAllow);
201     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY), dataParcel);
202 }
203 
GetBackgroundPolicyByUidFuzzTest(const uint8_t * data,size_t size)204 void GetBackgroundPolicyByUidFuzzTest(const uint8_t *data, size_t size)
205 {
206     NetManagerBaseAccessToken token;
207     uint32_t uid = NetPolicyGetData<uint32_t>();
208 
209     MessageParcel dataParcel;
210     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
211         return;
212     }
213     dataParcel.WriteUint32(uid);
214     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID), dataParcel);
215 }
216 
SetCellularPoliciesFuzzTest(const uint8_t * data,size_t size)217 void SetCellularPoliciesFuzzTest(const uint8_t *data, size_t size)
218 {
219     NetManagerBaseAccessToken token;
220 
221     uint32_t vectorSize = NetPolicyGetData<uint32_t>() % 21;
222     std::vector<NetQuotaPolicy> quotaPolicies;
223     for (uint32_t i = 0; i < vectorSize; i++) {
224         NetQuotaPolicy netQuotaPolicy;
225         netQuotaPolicy.networkmatchrule.netType = NetPolicyGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
226 
227         netQuotaPolicy.networkmatchrule.simId = NetPolicyGetString(STR_LEN);
228         netQuotaPolicy.networkmatchrule.ident = NetPolicyGetString(STR_LEN);
229         netQuotaPolicy.quotapolicy.periodStartTime = NetPolicyGetData<int64_t>();
230         netQuotaPolicy.quotapolicy.periodDuration = NetPolicyGetString(STR_LEN);
231 
232         netQuotaPolicy.quotapolicy.warningBytes = NetPolicyGetData<int64_t>();
233         netQuotaPolicy.quotapolicy.limitBytes = NetPolicyGetData<int64_t>();
234         netQuotaPolicy.quotapolicy.metered = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
235         netQuotaPolicy.quotapolicy.limitAction = NetPolicyGetData<uint32_t>() % CREATE_LIMIT_ACTION_VALUE == 0;
236 
237         quotaPolicies.push_back(netQuotaPolicy);
238     }
239 
240     MessageParcel dataParcel;
241     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
242         return;
243     }
244 
245     NetQuotaPolicy::Marshalling(dataParcel, quotaPolicies);
246 
247     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES), dataParcel);
248 }
249 
RegisterNetPolicyCallbackFuzzTest(const uint8_t * data,size_t size)250 void RegisterNetPolicyCallbackFuzzTest(const uint8_t *data, size_t size)
251 {
252     NetManagerBaseAccessToken token;
253     sptr<INetPolicyCallbackTest> callback = new (std::nothrow) INetPolicyCallbackTest();
254     if (callback == nullptr) {
255         return;
256     }
257 
258     MessageParcel dataParcel;
259     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
260         return;
261     }
262 
263     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
264 
265     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_REGISTER_NET_POLICY_CALLBACK), dataParcel);
266 }
267 
UnregisterNetPolicyCallbackFuzzTest(const uint8_t * data,size_t size)268 void UnregisterNetPolicyCallbackFuzzTest(const uint8_t *data, size_t size)
269 {
270     NetManagerBaseAccessToken token;
271     MessageParcel dataParcel;
272     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
273         return;
274     }
275     sptr<INetPolicyCallbackTest> callback = new (std::nothrow) INetPolicyCallbackTest();
276     if (callback == nullptr) {
277         return;
278     }
279     dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
280 
281     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UNREGISTER_NET_POLICY_CALLBACK), dataParcel);
282 }
283 
GetNetQuotaPoliciesFuzzTest(const uint8_t * data,size_t size)284 void GetNetQuotaPoliciesFuzzTest(const uint8_t *data, size_t size)
285 {
286     if ((data == nullptr) || (size == 0)) {
287         return;
288     }
289     NetManagerBaseAccessToken token;
290     MessageParcel dataParcel;
291     if (!WriteInterfaceToken(dataParcel)) {
292         return;
293     }
294 
295     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES), dataParcel);
296 }
297 
SetNetQuotaPoliciesFuzzTest(const uint8_t * data,size_t size)298 void SetNetQuotaPoliciesFuzzTest(const uint8_t *data, size_t size)
299 {
300     NetManagerBaseAccessToken token;
301     MessageParcel dataParcel;
302     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
303         return;
304     }
305     uint32_t vectorSize = NetPolicyGetData<uint32_t>() % 21;
306     std::vector<NetQuotaPolicy> quotaPolicies;
307     for (uint32_t i = 0; i < vectorSize; i++) {
308         NetQuotaPolicy netQuotaPolicy;
309         netQuotaPolicy.networkmatchrule.netType = NetPolicyGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
310 
311         netQuotaPolicy.networkmatchrule.simId = NetPolicyGetString(STR_LEN);
312         netQuotaPolicy.networkmatchrule.ident = NetPolicyGetString(STR_LEN);
313         netQuotaPolicy.quotapolicy.periodStartTime = NetPolicyGetData<int64_t>();
314         netQuotaPolicy.quotapolicy.periodDuration = NetPolicyGetString(STR_LEN);
315 
316         netQuotaPolicy.quotapolicy.warningBytes = NetPolicyGetData<int64_t>();
317         netQuotaPolicy.quotapolicy.limitBytes = NetPolicyGetData<int64_t>();
318         netQuotaPolicy.quotapolicy.metered = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
319         netQuotaPolicy.quotapolicy.limitAction = NetPolicyGetData<uint32_t>() % CREATE_LIMIT_ACTION_VALUE == 0;
320 
321         quotaPolicies.push_back(netQuotaPolicy);
322     }
323     NetQuotaPolicy::Marshalling(dataParcel, quotaPolicies);
324 
325     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES), dataParcel);
326 }
327 
IsUidNetAllowedFuzzTest(const uint8_t * data,size_t size)328 void IsUidNetAllowedFuzzTest(const uint8_t *data, size_t size)
329 {
330     NetManagerBaseAccessToken token;
331     MessageParcel dataParcel;
332     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
333         return;
334     }
335     uint32_t uid = NetPolicyGetData<uint32_t>();
336     bool metered = uid % CONVERT_NUMBER_TO_BOOL == 0;
337     std::string ifaceName = NetPolicyGetString(STR_LEN);
338     dataParcel.WriteUint32(uid);
339     dataParcel.WriteBool(metered);
340 
341     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED), dataParcel);
342 
343     MessageParcel dataParcel2;
344     if (!WriteInterfaceToken(dataParcel2)) {
345         return;
346     }
347 
348     dataParcel2.WriteUint32(uid);
349     dataParcel2.WriteString(ifaceName);
350 
351     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE), dataParcel2);
352 }
353 
ResetPoliciesFuzzTest(const uint8_t * data,size_t size)354 void ResetPoliciesFuzzTest(const uint8_t *data, size_t size)
355 {
356     NetManagerBaseAccessToken token;
357     std::string simId = NetPolicyGetString(STR_LEN);
358 
359     MessageParcel dataParcel;
360     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
361         return;
362     }
363 
364     dataParcel.WriteString(simId);
365 
366     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES), dataParcel);
367 }
368 
UpdateRemindPolicyFuzzTest(const uint8_t * data,size_t size)369 void UpdateRemindPolicyFuzzTest(const uint8_t *data, size_t size)
370 {
371     NetManagerBaseAccessToken token;
372     MessageParcel dataParcel;
373     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
374         return;
375     }
376     int32_t netType = NetPolicyGetData<int32_t>();
377     uint32_t remindType = NetPolicyGetData<uint32_t>();
378     std::string simId = NetPolicyGetString(STR_LEN);
379     dataParcel.WriteInt32(netType);
380     dataParcel.WriteString(simId);
381     dataParcel.WriteUint32(remindType);
382 
383     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY), dataParcel);
384 }
385 
SetDeviceIdleTrustlistFuzzTest(const uint8_t * data,size_t size)386 void SetDeviceIdleTrustlistFuzzTest(const uint8_t *data, size_t size)
387 {
388     NetManagerBaseAccessToken token;
389     MessageParcel dataParcel;
390     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
391         return;
392     }
393 
394     bool isAllowed = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
395     std::vector<uint32_t> uids = NetPolicyGetData<std::vector<uint32_t>>();
396     dataParcel.WriteUInt32Vector(uids);
397     dataParcel.WriteBool(isAllowed);
398 
399     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST), dataParcel);
400 }
401 
SetDeviceIdlePolicyFuzzTest(const uint8_t * data,size_t size)402 void SetDeviceIdlePolicyFuzzTest(const uint8_t *data, size_t size)
403 {
404     NetManagerBaseAccessToken token;
405     MessageParcel dataParcel;
406     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
407         return;
408     }
409 
410     bool enable = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
411     dataParcel.WriteBool(enable);
412 
413     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY), dataParcel);
414 }
415 
SetPowerSaveTrustlistFuzzTest(const uint8_t * data,size_t size)416 void SetPowerSaveTrustlistFuzzTest(const uint8_t *data, size_t size)
417 {
418     NetManagerBaseAccessToken token;
419     MessageParcel dataParcel;
420     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
421         return;
422     }
423 
424     bool isAllowed = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
425     std::vector<uint32_t> uids = NetPolicyGetData<std::vector<uint32_t>>();
426     dataParcel.WriteBool(isAllowed);
427     dataParcel.WriteUInt32Vector(uids);
428 
429     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST), dataParcel);
430 }
431 
GetPowerSaveTrustlistFuzzTest(const uint8_t * data,size_t size)432 void GetPowerSaveTrustlistFuzzTest(const uint8_t *data, size_t size)
433 {
434     NetManagerBaseAccessToken token;
435     MessageParcel dataParcel;
436     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
437         return;
438     }
439 
440     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST), dataParcel);
441 }
442 
GetDeviceIdleTrustlistFuzzTest(const uint8_t * data,size_t size)443 void GetDeviceIdleTrustlistFuzzTest(const uint8_t *data, size_t size)
444 {
445     NetManagerBaseAccessToken token;
446     MessageParcel dataParcel;
447     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
448         return;
449     }
450 
451     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST), dataParcel);
452 }
453 
GetBackgroundPolicyFuzzTest(const uint8_t * data,size_t size)454 void GetBackgroundPolicyFuzzTest(const uint8_t *data, size_t size)
455 {
456     NetManagerBaseAccessToken token;
457     MessageParcel dataParcel;
458     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
459         return;
460     }
461 
462     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY), dataParcel);
463 }
464 
SetPowerSavePolicyFuzzTest(const uint8_t * data,size_t size)465 void SetPowerSavePolicyFuzzTest(const uint8_t *data, size_t size)
466 {
467     NetManagerBaseAccessToken token;
468     MessageParcel dataParcel;
469     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
470         return;
471     }
472 
473     bool enable = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
474     dataParcel.WriteBool(enable);
475     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_POLICY), dataParcel);
476 }
477 
CheckPermissionFuzzTest(const uint8_t * data,size_t size)478 void CheckPermissionFuzzTest(const uint8_t *data, size_t size)
479 {
480     NetManagerBaseAccessToken token;
481     MessageParcel dataParcel;
482     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
483         return;
484     }
485 
486     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_CHECK_PERMISSION), dataParcel);
487 }
488 
489 /**
490  * @tc.name: SetNetworkAccessPolicy001
491  * @tc.desc: Test NetPolicyClient SetNetworkAccessPolicy.
492  * @tc.type: FUNC
493  */
SetNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)494 void SetNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
495 {
496     NetManagerBaseAccessToken token;
497     MessageParcel dataParcel;
498     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
499         return;
500     }
501     NetworkAccessPolicy netAccessPolicy;
502     uint32_t uid = NetPolicyGetData<uint32_t>();
503     netAccessPolicy.wifiAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
504     netAccessPolicy.cellularAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
505     bool reconfirmFlag = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
506 
507     dataParcel.WriteUint32(uid);
508     dataParcel.WriteUint8(netAccessPolicy.wifiAllow);
509     dataParcel.WriteUint8(netAccessPolicy.cellularAllow);
510     dataParcel.WriteBool(reconfirmFlag);
511     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY), dataParcel);
512 }
513 
514 /**
515  * @tc.name: GetNetworkAccessPolicy001
516  * @tc.desc: Test NetPolicyClient GetNetworkAccessPolicy.
517  * @tc.type: FUNC
518  */
GetNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)519 void GetNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
520 {
521     NetManagerBaseAccessToken token;
522     MessageParcel dataParcel;
523     if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
524         return;
525     }
526 
527     if (!WriteInterfaceToken(dataParcel)) {
528         return;
529     }
530 
531     bool flag = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
532     uint32_t uid = NetPolicyGetData<uint32_t>();
533     uint32_t userId = NetPolicyGetData<uint32_t>();
534     dataParcel.WriteBool(flag);
535     dataParcel.WriteInt32(uid);
536     dataParcel.WriteUint32(userId);
537     OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY), dataParcel);
538 }
539 } // namespace NetManagerStandard
540 } // namespace OHOS
541 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)542 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
543 {
544     /* Run your code on data */
545     OHOS::NetManagerStandard::SetPolicyByUidFuzzTest(data, size);
546     OHOS::NetManagerStandard::GetPolicyByUidFuzzTest(data, size);
547     OHOS::NetManagerStandard::GetUidsByPolicyFuzzTest(data, size);
548     OHOS::NetManagerStandard::GetBackgroundPolicyByUidFuzzTest(data, size);
549     OHOS::NetManagerStandard::SetCellularPoliciesFuzzTest(data, size);
550     OHOS::NetManagerStandard::RegisterNetPolicyCallbackFuzzTest(data, size);
551     OHOS::NetManagerStandard::GetNetQuotaPoliciesFuzzTest(data, size);
552     OHOS::NetManagerStandard::SetNetQuotaPoliciesFuzzTest(data, size);
553     OHOS::NetManagerStandard::IsUidNetAllowedFuzzTest(data, size);
554     OHOS::NetManagerStandard::ResetPoliciesFuzzTest(data, size);
555     OHOS::NetManagerStandard::UpdateRemindPolicyFuzzTest(data, size);
556     OHOS::NetManagerStandard::SetDeviceIdleTrustlistFuzzTest(data, size);
557     OHOS::NetManagerStandard::SetDeviceIdlePolicyFuzzTest(data, size);
558     OHOS::NetManagerStandard::SetPowerSaveTrustlistFuzzTest(data, size);
559     OHOS::NetManagerStandard::GetPowerSaveTrustlistFuzzTest(data, size);
560     OHOS::NetManagerStandard::UnregisterNetPolicyCallbackFuzzTest(data, size);
561     OHOS::NetManagerStandard::GetDeviceIdleTrustlistFuzzTest(data, size);
562     OHOS::NetManagerStandard::GetBackgroundPolicyFuzzTest(data, size);
563     OHOS::NetManagerStandard::SetPowerSavePolicyFuzzTest(data, size);
564     OHOS::NetManagerStandard::CheckPermissionFuzzTest(data, size);
565     OHOS::NetManagerStandard::SetNetworkAccessPolicyFuzzTest(data, size);
566     OHOS::NetManagerStandard::GetNetworkAccessPolicyFuzzTest(data, size);
567     return 0;
568 }