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 constexpr uint32_t MAX_IFACENAMES_SIZE = 128;
40 } // namespace
41
42 template<class T>
NetPolicyGetData()43 T NetPolicyGetData()
44 {
45 T object {};
46 size_t netPolicySize = sizeof(object);
47 if (g_baseFuzzData == nullptr || netPolicySize > g_baseFuzzSize - g_baseFuzzPos) {
48 return object;
49 }
50 errno_t ret = memcpy_s(&object, netPolicySize, g_baseFuzzData + g_baseFuzzPos, netPolicySize);
51 if (ret != EOK) {
52 return {};
53 }
54 g_baseFuzzPos += netPolicySize;
55 return object;
56 }
57
NetPolicyGetString(int strlen)58 std::string NetPolicyGetString(int strlen)
59 {
60 char cstr[strlen];
61 cstr[strlen - 1] = '\0';
62 for (int i = 0; i < strlen - 1; i++) {
63 cstr[i] = NetPolicyGetData<char>();
64 }
65 std::string str(cstr);
66 return str;
67 }
68
69 class INetPolicyCallbackTest : public IRemoteStub<INetPolicyCallback> {
70 public:
NetUidPolicyChange(uint32_t uid,uint32_t policy)71 int32_t NetUidPolicyChange(uint32_t uid, uint32_t policy)
72 {
73 return 0;
74 }
75
NetUidRuleChange(uint32_t uid,uint32_t rule)76 int32_t NetUidRuleChange(uint32_t uid, uint32_t rule)
77 {
78 return 0;
79 }
80
NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> & quotaPolicies)81 int32_t NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> "aPolicies)
82 {
83 return 0;
84 }
85
NetStrategySwitch(const std::string & simId,bool enable)86 int32_t NetStrategySwitch(const std::string &simId, bool enable)
87 {
88 return 0;
89 }
90
NetMeteredIfacesChange(std::vector<std::string> & ifaces)91 int32_t NetMeteredIfacesChange(std::vector<std::string> &ifaces)
92 {
93 return 0;
94 }
95
NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)96 int32_t NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)
97 {
98 return 0;
99 }
100 };
101
102 static bool g_isInited = false;
103
Init()104 void Init()
105 {
106 if (!g_isInited) {
107 DelayedSingleton<NetPolicyService>::GetInstance()->Init();
108 g_isInited = true;
109 }
110 }
111
OnRemoteRequest(uint32_t code,MessageParcel & data)112 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
113 {
114 if (!g_isInited) {
115 Init();
116 }
117
118 MessageParcel reply;
119 MessageOption option;
120
121 return DelayedSingleton<NetPolicyService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
122 }
123
WriteInterfaceToken(MessageParcel & data)124 bool WriteInterfaceToken(MessageParcel &data)
125 {
126 if (!data.WriteInterfaceToken(NetPolicyServiceStub::GetDescriptor())) {
127 return false;
128 }
129 return true;
130 }
131
IsValidPolicyFuzzData(const uint8_t * data,size_t size,MessageParcel & dataParcel)132 bool IsValidPolicyFuzzData(const uint8_t *data, size_t size, MessageParcel &dataParcel)
133 {
134 if ((data == nullptr) || (size == 0)) {
135 return false;
136 }
137
138 g_baseFuzzData = data;
139 g_baseFuzzSize = size;
140 g_baseFuzzPos = 0;
141
142 if (!WriteInterfaceToken(dataParcel)) {
143 return false;
144 }
145 return true;
146 }
147
SetPolicyByUidFuzzTest(const uint8_t * data,size_t size)148 void SetPolicyByUidFuzzTest(const uint8_t *data, size_t size)
149 {
150 NetManagerBaseAccessToken token;
151 MessageParcel dataParcel;
152 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
153 return;
154 }
155
156 uint32_t uid = NetPolicyGetData<uint32_t>();
157 uint32_t policy = NetPolicyGetData<uint32_t>() % 3;
158 dataParcel.WriteUint32(uid);
159 dataParcel.WriteUint32(policy);
160
161 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POLICY_BY_UID), dataParcel);
162 }
163
GetPolicyByUidFuzzTest(const uint8_t * data,size_t size)164 void GetPolicyByUidFuzzTest(const uint8_t *data, size_t size)
165 {
166 NetManagerBaseAccessToken token;
167 uint32_t uid = NetPolicyGetData<uint32_t>();
168
169 MessageParcel dataParcel;
170 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
171 return;
172 }
173 dataParcel.WriteUint32(uid);
174
175 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POLICY_BY_UID), dataParcel);
176 }
177
GetUidsByPolicyFuzzTest(const uint8_t * data,size_t size)178 void GetUidsByPolicyFuzzTest(const uint8_t *data, size_t size)
179 {
180 NetManagerBaseAccessToken token;
181
182 MessageParcel dataParcel;
183 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
184 return;
185 }
186 uint32_t policy = NetPolicyGetData<uint32_t>() % 3;
187 dataParcel.WriteUint32(policy);
188
189 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_UIDS_BY_POLICY), dataParcel);
190 }
191
SetBackgroundPolicyFuzzTest(const uint8_t * data,size_t size)192 void SetBackgroundPolicyFuzzTest(const uint8_t *data, size_t size)
193 {
194 NetManagerBaseAccessToken token;
195 bool isBackgroundPolicyAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
196
197 MessageParcel dataParcel;
198 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
199 return;
200 }
201 dataParcel.WriteBool(isBackgroundPolicyAllow);
202 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_BACKGROUND_POLICY), dataParcel);
203 }
204
GetBackgroundPolicyByUidFuzzTest(const uint8_t * data,size_t size)205 void GetBackgroundPolicyByUidFuzzTest(const uint8_t *data, size_t size)
206 {
207 NetManagerBaseAccessToken token;
208 uint32_t uid = NetPolicyGetData<uint32_t>();
209
210 MessageParcel dataParcel;
211 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
212 return;
213 }
214 dataParcel.WriteUint32(uid);
215 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY_BY_UID), dataParcel);
216 }
217
SetCellularPoliciesFuzzTest(const uint8_t * data,size_t size)218 void SetCellularPoliciesFuzzTest(const uint8_t *data, size_t size)
219 {
220 NetManagerBaseAccessToken token;
221
222 uint32_t vectorSize = NetPolicyGetData<uint32_t>() % 21;
223 std::vector<NetQuotaPolicy> quotaPolicies;
224 for (uint32_t i = 0; i < vectorSize; i++) {
225 NetQuotaPolicy netQuotaPolicy;
226 netQuotaPolicy.networkmatchrule.netType = NetPolicyGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
227
228 netQuotaPolicy.networkmatchrule.simId = NetPolicyGetString(STR_LEN);
229 netQuotaPolicy.networkmatchrule.ident = NetPolicyGetString(STR_LEN);
230 netQuotaPolicy.quotapolicy.periodStartTime = NetPolicyGetData<int64_t>();
231 netQuotaPolicy.quotapolicy.periodDuration = NetPolicyGetString(STR_LEN);
232
233 netQuotaPolicy.quotapolicy.warningBytes = NetPolicyGetData<int64_t>();
234 netQuotaPolicy.quotapolicy.limitBytes = NetPolicyGetData<int64_t>();
235 netQuotaPolicy.quotapolicy.metered = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
236 netQuotaPolicy.quotapolicy.limitAction = NetPolicyGetData<uint32_t>() % CREATE_LIMIT_ACTION_VALUE == 0;
237
238 quotaPolicies.push_back(netQuotaPolicy);
239 }
240
241 MessageParcel dataParcel;
242 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
243 return;
244 }
245
246 NetQuotaPolicy::Marshalling(dataParcel, quotaPolicies);
247
248 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES), dataParcel);
249 }
250
RegisterNetPolicyCallbackFuzzTest(const uint8_t * data,size_t size)251 void RegisterNetPolicyCallbackFuzzTest(const uint8_t *data, size_t size)
252 {
253 NetManagerBaseAccessToken token;
254 sptr<INetPolicyCallbackTest> callback = new (std::nothrow) INetPolicyCallbackTest();
255 if (callback == nullptr) {
256 return;
257 }
258
259 MessageParcel dataParcel;
260 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
261 return;
262 }
263
264 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
265
266 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_REGISTER_NET_POLICY_CALLBACK), dataParcel);
267 }
268
UnregisterNetPolicyCallbackFuzzTest(const uint8_t * data,size_t size)269 void UnregisterNetPolicyCallbackFuzzTest(const uint8_t *data, size_t size)
270 {
271 NetManagerBaseAccessToken token;
272 MessageParcel dataParcel;
273 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
274 return;
275 }
276 sptr<INetPolicyCallbackTest> callback = new (std::nothrow) INetPolicyCallbackTest();
277 if (callback == nullptr) {
278 return;
279 }
280 dataParcel.WriteRemoteObject(callback->AsObject().GetRefPtr());
281
282 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UNREGISTER_NET_POLICY_CALLBACK), dataParcel);
283 }
284
GetNetQuotaPoliciesFuzzTest(const uint8_t * data,size_t size)285 void GetNetQuotaPoliciesFuzzTest(const uint8_t *data, size_t size)
286 {
287 if (data == nullptr) {
288 return;
289 }
290 NetManagerBaseAccessToken token;
291 MessageParcel dataParcel;
292 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
293 return;
294 }
295
296 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NET_QUOTA_POLICIES), dataParcel);
297 }
298
SetNetQuotaPoliciesFuzzTest(const uint8_t * data,size_t size)299 void SetNetQuotaPoliciesFuzzTest(const uint8_t *data, size_t size)
300 {
301 NetManagerBaseAccessToken token;
302 MessageParcel dataParcel;
303 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
304 return;
305 }
306 uint32_t vectorSize = NetPolicyGetData<uint32_t>() % 21;
307 std::vector<NetQuotaPolicy> quotaPolicies;
308 for (uint32_t i = 0; i < vectorSize; i++) {
309 NetQuotaPolicy netQuotaPolicy;
310 netQuotaPolicy.networkmatchrule.netType = NetPolicyGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
311
312 netQuotaPolicy.networkmatchrule.simId = NetPolicyGetString(STR_LEN);
313 netQuotaPolicy.networkmatchrule.ident = NetPolicyGetString(STR_LEN);
314 netQuotaPolicy.quotapolicy.periodStartTime = NetPolicyGetData<int64_t>();
315 netQuotaPolicy.quotapolicy.periodDuration = NetPolicyGetString(STR_LEN);
316
317 netQuotaPolicy.quotapolicy.warningBytes = NetPolicyGetData<int64_t>();
318 netQuotaPolicy.quotapolicy.limitBytes = NetPolicyGetData<int64_t>();
319 netQuotaPolicy.quotapolicy.metered = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
320 netQuotaPolicy.quotapolicy.limitAction = NetPolicyGetData<uint32_t>() % CREATE_LIMIT_ACTION_VALUE == 0;
321
322 quotaPolicies.push_back(netQuotaPolicy);
323 }
324 NetQuotaPolicy::Marshalling(dataParcel, quotaPolicies);
325
326 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NET_QUOTA_POLICIES), dataParcel);
327 }
328
IsUidNetAllowedFuzzTest(const uint8_t * data,size_t size)329 void IsUidNetAllowedFuzzTest(const uint8_t *data, size_t size)
330 {
331 NetManagerBaseAccessToken token;
332 MessageParcel dataParcel;
333 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
334 return;
335 }
336 uint32_t uid = NetPolicyGetData<uint32_t>();
337 bool metered = uid % CONVERT_NUMBER_TO_BOOL == 0;
338 std::string ifaceName = NetPolicyGetString(STR_LEN);
339 dataParcel.WriteUint32(uid);
340 dataParcel.WriteBool(metered);
341
342 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_METERED), dataParcel);
343
344 MessageParcel dataParcel2;
345 if (!WriteInterfaceToken(dataParcel2)) {
346 return;
347 }
348
349 dataParcel2.WriteUint32(uid);
350 dataParcel2.WriteString(ifaceName);
351
352 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_IS_NET_ALLOWED_BY_IFACE), dataParcel2);
353 }
354
ResetPoliciesFuzzTest(const uint8_t * data,size_t size)355 void ResetPoliciesFuzzTest(const uint8_t *data, size_t size)
356 {
357 NetManagerBaseAccessToken token;
358 std::string simId = NetPolicyGetString(STR_LEN);
359
360 MessageParcel dataParcel;
361 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
362 return;
363 }
364
365 dataParcel.WriteString(simId);
366
367 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_RESET_POLICIES), dataParcel);
368 }
369
UpdateRemindPolicyFuzzTest(const uint8_t * data,size_t size)370 void UpdateRemindPolicyFuzzTest(const uint8_t *data, size_t size)
371 {
372 NetManagerBaseAccessToken token;
373 MessageParcel dataParcel;
374 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
375 return;
376 }
377 int32_t netType = NetPolicyGetData<int32_t>();
378 uint32_t remindType = NetPolicyGetData<uint32_t>();
379 std::string simId = NetPolicyGetString(STR_LEN);
380 dataParcel.WriteInt32(netType);
381 dataParcel.WriteString(simId);
382 dataParcel.WriteUint32(remindType);
383
384 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_UPDATE_REMIND_POLICY), dataParcel);
385 }
386
SetDeviceIdleTrustlistFuzzTest(const uint8_t * data,size_t size)387 void SetDeviceIdleTrustlistFuzzTest(const uint8_t *data, size_t size)
388 {
389 NetManagerBaseAccessToken token;
390 MessageParcel dataParcel;
391 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
392 return;
393 }
394
395 bool isAllowed = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
396 std::vector<uint32_t> uids;
397 dataParcel.WriteUInt32Vector(uids);
398 dataParcel.WriteBool(isAllowed);
399
400 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_IDLE_TRUSTLIST), dataParcel);
401 }
402
SetDeviceIdlePolicyFuzzTest(const uint8_t * data,size_t size)403 void SetDeviceIdlePolicyFuzzTest(const uint8_t *data, size_t size)
404 {
405 NetManagerBaseAccessToken token;
406 MessageParcel dataParcel;
407 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
408 return;
409 }
410
411 bool enable = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
412 dataParcel.WriteBool(enable);
413
414 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_DEVICE_IDLE_POLICY), dataParcel);
415 }
416
SetPowerSaveTrustlistFuzzTest(const uint8_t * data,size_t size)417 void SetPowerSaveTrustlistFuzzTest(const uint8_t *data, size_t size)
418 {
419 NetManagerBaseAccessToken token;
420 MessageParcel dataParcel;
421 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
422 return;
423 }
424
425 bool isAllowed = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
426 std::vector<uint32_t> uids;
427 dataParcel.WriteBool(isAllowed);
428 dataParcel.WriteUInt32Vector(uids);
429
430 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_TRUSTLIST), dataParcel);
431 }
432
GetPowerSaveTrustlistFuzzTest(const uint8_t * data,size_t size)433 void GetPowerSaveTrustlistFuzzTest(const uint8_t *data, size_t size)
434 {
435 NetManagerBaseAccessToken token;
436 MessageParcel dataParcel;
437 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
438 return;
439 }
440
441 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_POWER_SAVE_TRUSTLIST), dataParcel);
442 }
443
GetDeviceIdleTrustlistFuzzTest(const uint8_t * data,size_t size)444 void GetDeviceIdleTrustlistFuzzTest(const uint8_t *data, size_t size)
445 {
446 NetManagerBaseAccessToken token;
447 MessageParcel dataParcel;
448 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
449 return;
450 }
451
452 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_IDLE_TRUSTLIST), dataParcel);
453 }
454
GetBackgroundPolicyFuzzTest(const uint8_t * data,size_t size)455 void GetBackgroundPolicyFuzzTest(const uint8_t *data, size_t size)
456 {
457 NetManagerBaseAccessToken token;
458 MessageParcel dataParcel;
459 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
460 return;
461 }
462
463 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_BACKGROUND_POLICY), dataParcel);
464 }
465
SetPowerSavePolicyFuzzTest(const uint8_t * data,size_t size)466 void SetPowerSavePolicyFuzzTest(const uint8_t *data, size_t size)
467 {
468 NetManagerBaseAccessToken token;
469 MessageParcel dataParcel;
470 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
471 return;
472 }
473
474 bool enable = NetPolicyGetData<int32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
475 dataParcel.WriteBool(enable);
476 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_POWER_SAVE_POLICY), dataParcel);
477 }
478
CheckPermissionFuzzTest(const uint8_t * data,size_t size)479 void CheckPermissionFuzzTest(const uint8_t *data, size_t size)
480 {
481 NetManagerBaseAccessToken token;
482 MessageParcel dataParcel;
483 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
484 return;
485 }
486
487 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_CHECK_PERMISSION), dataParcel);
488 }
489
490 /**
491 * @tc.name: SetNetworkAccessPolicy001
492 * @tc.desc: Test NetPolicyClient SetNetworkAccessPolicy.
493 * @tc.type: FUNC
494 */
SetNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)495 void SetNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
496 {
497 NetManagerBaseAccessToken token;
498 MessageParcel dataParcel;
499 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
500 return;
501 }
502 NetworkAccessPolicy netAccessPolicy;
503 uint32_t uid = NetPolicyGetData<uint32_t>();
504 netAccessPolicy.wifiAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
505 netAccessPolicy.cellularAllow = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
506 bool reconfirmFlag = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
507
508 dataParcel.WriteUint32(uid);
509 dataParcel.WriteUint8(netAccessPolicy.wifiAllow);
510 dataParcel.WriteUint8(netAccessPolicy.cellularAllow);
511 dataParcel.WriteBool(reconfirmFlag);
512 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NETWORK_ACCESS_POLICY), dataParcel);
513 }
514
515 /**
516 * @tc.name: GetNetworkAccessPolicy001
517 * @tc.desc: Test NetPolicyClient GetNetworkAccessPolicy.
518 * @tc.type: FUNC
519 */
GetNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)520 void GetNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
521 {
522 NetManagerBaseAccessToken token;
523 MessageParcel dataParcel;
524 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
525 return;
526 }
527
528 if (!WriteInterfaceToken(dataParcel)) {
529 return;
530 }
531
532 bool flag = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
533 uint32_t uid = NetPolicyGetData<uint32_t>();
534 uint32_t userId = NetPolicyGetData<uint32_t>();
535 dataParcel.WriteBool(flag);
536 dataParcel.WriteInt32(uid);
537 dataParcel.WriteUint32(userId);
538 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_GET_NETWORK_ACCESS_POLICY), dataParcel);
539 }
540
541 /**
542 * @tc.name: NotifyNetAccessPolicyDiagFuzzTest
543 * @tc.desc: Test NetPolicyClient NotifyNetAccessPolicyDiag.
544 * @tc.type: FUNC
545 */
NotifyNetAccessPolicyDiagFuzzTest(const uint8_t * data,size_t size)546 void NotifyNetAccessPolicyDiagFuzzTest(const uint8_t *data, size_t size)
547 {
548 NetManagerBaseAccessToken token;
549 MessageParcel dataParcel;
550 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
551 return;
552 }
553
554 if (!WriteInterfaceToken(dataParcel)) {
555 return;
556 }
557
558 uint32_t uid = NetPolicyGetData<uint32_t>();
559 dataParcel.WriteInt32(uid);
560 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_NOTIFY_NETWORK_ACCESS_POLICY_DIAG), dataParcel);
561 }
562
SetNicTrafficAllowedFuzzTest(const uint8_t * data,size_t size)563 void SetNicTrafficAllowedFuzzTest(const uint8_t *data, size_t size)
564 {
565 NetManagerBaseAccessToken token;
566 MessageParcel dataParcel;
567 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
568 return;
569 }
570
571 bool status = NetPolicyGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL;
572 int32_t ifaceNamesSize = NetPolicyGetData<int32_t>() % MAX_IFACENAMES_SIZE;
573 dataParcel.WriteBool(status);
574 dataParcel.WriteInt32(ifaceNamesSize);
575 for (int32_t i = 0; i < ifaceNamesSize; i++) {
576 dataParcel.WriteString(NetPolicyGetString(STR_LEN));
577 }
578 OnRemoteRequest(static_cast<uint32_t>(PolicyInterfaceCode::CMD_NPS_SET_NIC_TRAFFIC_ALLOWED), dataParcel);
579 }
580
OnExtensionFuzzTest(const uint8_t * data,size_t size)581 void OnExtensionFuzzTest(const uint8_t *data, size_t size)
582 {
583 NetManagerBaseAccessToken token;
584 MessageParcel dataParcel;
585 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
586 return;
587 }
588 if (!WriteInterfaceToken(dataParcel)) {
589 return;
590 }
591
592 MessageParcel data0;
593 MessageParcel reply0;
594 std::string extension = NetPolicyGetString(STR_LEN);
595 DelayedSingleton<NetPolicyService>::GetInstance()->OnExtension(extension, data0, reply0);
596
597 MessageParcel data1;
598 MessageParcel reply1;
599 extension = "backup";
600 DelayedSingleton<NetPolicyService>::GetInstance()->OnExtension(extension, data1, reply1);
601
602 MessageParcel data2;
603 MessageParcel reply2;
604 extension = "restore";
605 data2.WriteFileDescriptor(-1);
606 DelayedSingleton<NetPolicyService>::GetInstance()->OnExtension(extension, data2, reply2);
607 data2.WriteFileDescriptor(NetPolicyGetData<uint16_t>());
608 DelayedSingleton<NetPolicyService>::GetInstance()->OnExtension(extension, data2, reply2);
609 }
610
DeleteNetworkAccessPolicyFuzzTest(const uint8_t * data,size_t size)611 void DeleteNetworkAccessPolicyFuzzTest(const uint8_t *data, size_t size)
612 {
613 NetManagerBaseAccessToken token;
614 MessageParcel dataParcel;
615 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
616 return;
617 }
618 if (!WriteInterfaceToken(dataParcel)) {
619 return;
620 }
621 uint32_t uid = NetPolicyGetData<uint32_t>();
622 DelayedSingleton<NetPolicyService>::GetInstance()->DeleteNetworkAccessPolicy(uid);
623 }
624
SetNicTrafficAllowedFuzzTest02(const uint8_t * data,size_t size)625 void SetNicTrafficAllowedFuzzTest02(const uint8_t *data, size_t size)
626 {
627 NetManagerBaseAccessToken token;
628 MessageParcel dataParcel;
629 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
630 return;
631 }
632 if (!WriteInterfaceToken(dataParcel)) {
633 return;
634 }
635 std::vector<std::string> ifaceNames;
636 ifaceNames.push_back(NetPolicyGetString(STR_LEN));
637 ifaceNames.push_back(NetPolicyGetString(STR_LEN));
638 bool status = NetPolicyGetData<bool>();
639 DelayedSingleton<NetPolicyService>::GetInstance()->SetNicTrafficAllowed(ifaceNames, status);
640 }
641
DelBrokerUidAccessPolicyMapFuzzTest(const uint8_t * data,size_t size)642 void DelBrokerUidAccessPolicyMapFuzzTest(const uint8_t *data, size_t size)
643 {
644 NetManagerBaseAccessToken token;
645 MessageParcel dataParcel;
646 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
647 return;
648 }
649 if (!WriteInterfaceToken(dataParcel)) {
650 return;
651 }
652 uint32_t uid = NetPolicyGetData<uint32_t>();
653 DelayedSingleton<NetPolicyService>::GetInstance()->DelBrokerUidAccessPolicyMap(uid);
654 }
655
UpdateNetworkAccessPolicyFromConfigFuzzTest(const uint8_t * data,size_t size)656 void UpdateNetworkAccessPolicyFromConfigFuzzTest(const uint8_t *data, size_t size)
657 {
658 NetManagerBaseAccessToken token;
659 MessageParcel dataParcel;
660 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
661 return;
662 }
663 if (!WriteInterfaceToken(dataParcel)) {
664 return;
665 }
666 std::string bundleName = NetPolicyGetString(STR_LEN);
667 NetworkAccessPolicy policy;
668 DelayedSingleton<NetPolicyService>::GetInstance()->UpdateNetworkAccessPolicyFromConfig(bundleName, policy);
669 }
670
ResetNetAccessPolicyFuzzTest(const uint8_t * data,size_t size)671 void ResetNetAccessPolicyFuzzTest(const uint8_t *data, size_t size)
672 {
673 NetManagerBaseAccessToken token;
674 MessageParcel dataParcel;
675 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
676 return;
677 }
678 if (!WriteInterfaceToken(dataParcel)) {
679 return;
680 }
681
682 DelayedSingleton<NetPolicyService>::GetInstance()->ResetNetAccessPolicy();
683 }
684
FactoryResetPoliciesFuzzTest(const uint8_t * data,size_t size)685 void FactoryResetPoliciesFuzzTest(const uint8_t *data, size_t size)
686 {
687 NetManagerBaseAccessToken token;
688 MessageParcel dataParcel;
689 if (!IsValidPolicyFuzzData(data, size, dataParcel)) {
690 return;
691 }
692 if (!WriteInterfaceToken(dataParcel)) {
693 return;
694 }
695
696 DelayedSingleton<NetPolicyService>::GetInstance()->FactoryResetPolicies();
697 }
698 } // namespace NetManagerStandard
699 } // namespace OHOS
700
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)701 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
702 {
703 /* Run your code on data */
704 OHOS::NetManagerStandard::SetPolicyByUidFuzzTest(data, size);
705 OHOS::NetManagerStandard::GetPolicyByUidFuzzTest(data, size);
706 OHOS::NetManagerStandard::GetUidsByPolicyFuzzTest(data, size);
707 OHOS::NetManagerStandard::GetBackgroundPolicyByUidFuzzTest(data, size);
708 OHOS::NetManagerStandard::SetCellularPoliciesFuzzTest(data, size);
709 OHOS::NetManagerStandard::RegisterNetPolicyCallbackFuzzTest(data, size);
710 OHOS::NetManagerStandard::GetNetQuotaPoliciesFuzzTest(data, size);
711 OHOS::NetManagerStandard::SetNetQuotaPoliciesFuzzTest(data, size);
712 OHOS::NetManagerStandard::IsUidNetAllowedFuzzTest(data, size);
713 OHOS::NetManagerStandard::ResetPoliciesFuzzTest(data, size);
714 OHOS::NetManagerStandard::UpdateRemindPolicyFuzzTest(data, size);
715 OHOS::NetManagerStandard::SetDeviceIdleTrustlistFuzzTest(data, size);
716 OHOS::NetManagerStandard::SetDeviceIdlePolicyFuzzTest(data, size);
717 OHOS::NetManagerStandard::SetPowerSaveTrustlistFuzzTest(data, size);
718 OHOS::NetManagerStandard::GetPowerSaveTrustlistFuzzTest(data, size);
719 OHOS::NetManagerStandard::UnregisterNetPolicyCallbackFuzzTest(data, size);
720 OHOS::NetManagerStandard::GetDeviceIdleTrustlistFuzzTest(data, size);
721 OHOS::NetManagerStandard::GetBackgroundPolicyFuzzTest(data, size);
722 OHOS::NetManagerStandard::SetPowerSavePolicyFuzzTest(data, size);
723 OHOS::NetManagerStandard::CheckPermissionFuzzTest(data, size);
724 OHOS::NetManagerStandard::SetNetworkAccessPolicyFuzzTest(data, size);
725 OHOS::NetManagerStandard::GetNetworkAccessPolicyFuzzTest(data, size);
726 OHOS::NetManagerStandard::NotifyNetAccessPolicyDiagFuzzTest(data, size);
727 OHOS::NetManagerStandard::SetNicTrafficAllowedFuzzTest(data, size);
728 OHOS::NetManagerStandard::OnExtensionFuzzTest(data, size);
729 OHOS::NetManagerStandard::DeleteNetworkAccessPolicyFuzzTest(data, size);
730 OHOS::NetManagerStandard::SetNicTrafficAllowedFuzzTest02(data, size);
731 OHOS::NetManagerStandard::DelBrokerUidAccessPolicyMapFuzzTest(data, size);
732 OHOS::NetManagerStandard::UpdateNetworkAccessPolicyFromConfigFuzzTest(data, size);
733 OHOS::NetManagerStandard::ResetNetAccessPolicyFuzzTest(data, size);
734 OHOS::NetManagerStandard::FactoryResetPoliciesFuzzTest(data, size);
735 return 0;
736 }