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 "common_notify_callback_test.h"
20 #include "iservice_registry.h"
21 #include "netsys_native_client.h"
22 #include "notify_callback_stub.h"
23 #include "singleton.h"
24 #include "system_ability_definition.h"
25 #define private public
26 #include "iptables_wrapper.h"
27 #include "netsys_native_service.h"
28 #include "netsys_native_service_stub.h"
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 const uint8_t *g_baseFuzzData = nullptr;
33 static constexpr uint32_t CONVERT_NUMBER_TO_BOOL = 2;
34 size_t g_baseFuzzSize = 0;
35 size_t g_baseFuzzPos;
36 constexpr size_t STR_LEN = 10;
37 constexpr size_t VECTOR_MAX_SIZE = 15;
38 } // namespace
39
GetData()40 template <class T> T GetData()
41 {
42 T object{};
43 size_t objectSize = sizeof(object);
44 if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
45 return object;
46 }
47 errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
48 if (ret != EOK) {
49 return {};
50 }
51 g_baseFuzzPos += objectSize;
52 return object;
53 }
54
GetStringFromData(int strlen)55 std::string GetStringFromData(int strlen)
56 {
57 char cstr[strlen];
58 cstr[strlen - 1] = '\0';
59 for (int i = 0; i < strlen - 1; i++) {
60 cstr[i] = GetData<char>();
61 }
62 std::string str(cstr);
63 return str;
64 }
65
66 static bool g_isInited = false;
Init()67 void Init()
68 {
69 nmd::IptablesWrapper::GetInstance();
70 if (!DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->Init()) {
71 g_isInited = false;
72 } else {
73 g_isInited = true;
74 }
75 }
76
OnRemoteRequest(uint32_t code,MessageParcel & data)77 int32_t OnRemoteRequest(uint32_t code, MessageParcel &data)
78 {
79 if (!g_isInited) {
80 Init();
81 }
82
83 MessageParcel reply;
84 MessageOption option;
85
86 int32_t ret =
87 DelayedSingleton<NetsysNative::NetsysNativeService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
88 return ret;
89 }
90
WriteInterfaceToken(MessageParcel & data)91 bool WriteInterfaceToken(MessageParcel &data)
92 {
93 if (!data.WriteInterfaceToken(NetsysNative::NetsysNativeServiceStub::GetDescriptor())) {
94 return false;
95 }
96 return true;
97 }
98
WriteInterfaceTokenCallback(MessageParcel & data)99 bool WriteInterfaceTokenCallback(MessageParcel &data)
100 {
101 if (!data.WriteInterfaceToken(NetsysNative::NotifyCallbackStub::GetDescriptor())) {
102 return false;
103 }
104 return true;
105 }
106
107 class INetSysCallbackTest : public NetsysNative::NotifyCallbackStub {
108 public:
INetSysCallbackTest()109 INetSysCallbackTest() : NotifyCallbackStub() {}
~INetSysCallbackTest()110 virtual ~INetSysCallbackTest() {}
111 };
112
113 static NetsysNative::NetsysNativeService g_netSysNativeClient;
114
IsDataAndSizeValid(const uint8_t * data,size_t size,MessageParcel & dataParcel)115 bool IsDataAndSizeValid(const uint8_t *data, size_t size, MessageParcel &dataParcel)
116 {
117 if ((data == nullptr) || (size == 0)) {
118 return false;
119 }
120 g_baseFuzzData = data;
121 g_baseFuzzSize = size;
122 g_baseFuzzPos = 0;
123
124 if (!WriteInterfaceToken(dataParcel)) {
125 return false;
126 }
127 return true;
128 }
129
NetworkCreatePhysicalFuzzTest(const uint8_t * data,size_t size)130 void NetworkCreatePhysicalFuzzTest(const uint8_t *data, size_t size)
131 {
132 MessageParcel dataParcel;
133 if (!IsDataAndSizeValid(data, size, dataParcel)) {
134 return;
135 }
136
137 int32_t netId = GetData<int32_t>();
138 int32_t permission = GetData<int32_t>();
139
140 dataParcel.WriteInt32(netId);
141 dataParcel.WriteInt32(permission);
142 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_PHYSICAL),
143 dataParcel);
144 }
145
NetworkDestroyFuzzTest(const uint8_t * data,size_t size)146 void NetworkDestroyFuzzTest(const uint8_t *data, size_t size)
147 {
148 MessageParcel dataParcel;
149 if (!IsDataAndSizeValid(data, size, dataParcel)) {
150 return;
151 }
152
153 int32_t netId = GetData<int32_t>();
154 dataParcel.WriteInt32(netId);
155 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DESTROY), dataParcel);
156 }
157
NetworkAddInterfaceFuzzTest(const uint8_t * data,size_t size)158 void NetworkAddInterfaceFuzzTest(const uint8_t *data, size_t size)
159 {
160 MessageParcel dataParcel;
161 if (!IsDataAndSizeValid(data, size, dataParcel)) {
162 return;
163 }
164
165 int32_t netId = GetData<int32_t>();
166 std::string iface = GetStringFromData(STR_LEN);
167
168 dataParcel.WriteInt32(netId);
169 dataParcel.WriteString(iface);
170 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_INTERFACE), dataParcel);
171 }
172
NetworkRemoveInterfaceFuzzTest(const uint8_t * data,size_t size)173 void NetworkRemoveInterfaceFuzzTest(const uint8_t *data, size_t size)
174 {
175 MessageParcel dataParcel;
176 if (!IsDataAndSizeValid(data, size, dataParcel)) {
177 return;
178 }
179
180 int32_t netId = GetData<int32_t>();
181 std::string iface = GetStringFromData(STR_LEN);
182
183 dataParcel.WriteInt32(netId);
184 dataParcel.WriteString(iface);
185 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_INTERFACE),
186 dataParcel);
187 }
188
NetworkAddRouteFuzzTest(const uint8_t * data,size_t size)189 void NetworkAddRouteFuzzTest(const uint8_t *data, size_t size)
190 {
191 MessageParcel dataParcel;
192 if (!IsDataAndSizeValid(data, size, dataParcel)) {
193 return;
194 }
195
196 int32_t netId = GetData<int32_t>();
197 std::string ifName = GetStringFromData(STR_LEN);
198 std::string destination = GetStringFromData(STR_LEN);
199 std::string nextHop = GetStringFromData(STR_LEN);
200
201 dataParcel.WriteInt32(netId);
202 dataParcel.WriteString(ifName);
203 dataParcel.WriteString(destination);
204 dataParcel.WriteString(nextHop);
205 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE), dataParcel);
206 }
207
NetworkRemoveRouteFuzzTest(const uint8_t * data,size_t size)208 void NetworkRemoveRouteFuzzTest(const uint8_t *data, size_t size)
209 {
210 MessageParcel dataParcel;
211 if (!IsDataAndSizeValid(data, size, dataParcel)) {
212 return;
213 }
214
215 int32_t netId = GetData<int32_t>();
216 std::string ifName = GetStringFromData(STR_LEN);
217 std::string destination = GetStringFromData(STR_LEN);
218 std::string nextHop = GetStringFromData(STR_LEN);
219
220 dataParcel.WriteInt32(netId);
221 dataParcel.WriteString(ifName);
222 dataParcel.WriteString(destination);
223 dataParcel.WriteString(nextHop);
224 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_ROUTE), dataParcel);
225 }
226
GetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)227 void GetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
228 {
229 MessageParcel dataParcel;
230 if (!IsDataAndSizeValid(data, size, dataParcel)) {
231 return;
232 }
233
234 OHOS::nmd::InterfaceConfigurationParcel cfg;
235 cfg.ifName = GetStringFromData(STR_LEN);
236
237 dataParcel.WriteString(cfg.ifName);
238 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_CONFIG), dataParcel);
239 }
240
GetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)241 void GetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
242 {
243 MessageParcel dataParcel;
244 if (!IsDataAndSizeValid(data, size, dataParcel)) {
245 return;
246 }
247
248 std::string interfaceName = GetStringFromData(STR_LEN);
249
250 dataParcel.WriteString(interfaceName);
251 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_MTU), dataParcel);
252 }
253
SetInterfaceMtuFuzzTest(const uint8_t * data,size_t size)254 void SetInterfaceMtuFuzzTest(const uint8_t *data, size_t size)
255 {
256 MessageParcel dataParcel;
257 if (!IsDataAndSizeValid(data, size, dataParcel)) {
258 return;
259 }
260
261 int32_t mtu = GetData<int32_t>();
262 std::string interfaceName = GetStringFromData(STR_LEN);
263
264 dataParcel.WriteString(interfaceName);
265 dataParcel.WriteInt32(mtu);
266 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_MTU), dataParcel);
267 }
268
AddInterfaceAddressFuzzTest(const uint8_t * data,size_t size)269 void AddInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
270 {
271 MessageParcel dataParcel;
272 if (!IsDataAndSizeValid(data, size, dataParcel)) {
273 return;
274 }
275
276 std::string interfaceName = GetStringFromData(STR_LEN);
277 std::string ipAddr = GetStringFromData(STR_LEN);
278 int32_t prefixLength = GetData<int32_t>();
279
280 dataParcel.WriteString(interfaceName);
281 dataParcel.WriteString(ipAddr);
282 dataParcel.WriteInt32(prefixLength);
283 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_ADD_ADDRESS), dataParcel);
284 }
285
OnRemoteRequestCallBack(uint32_t code,MessageParcel & data)286 int32_t OnRemoteRequestCallBack(uint32_t code, MessageParcel &data)
287 {
288 MessageParcel reply;
289 MessageOption option;
290 NetsysNative::NotifyCallbackTest notifyCallBackTest;
291 int32_t ret = notifyCallBackTest.OnRemoteRequest(code, data, reply, option);
292 return ret;
293 }
294
OnInterfaceAddressUpdatedFuzzTest(const uint8_t * data,size_t size)295 void OnInterfaceAddressUpdatedFuzzTest(const uint8_t *data, size_t size)
296 {
297 if ((data == nullptr) || (size == 0)) {
298 return;
299 }
300 g_baseFuzzData = data;
301 g_baseFuzzSize = size;
302 g_baseFuzzPos = 0;
303
304 std::string addr = GetStringFromData(STR_LEN);
305 std::string ifName = GetStringFromData(STR_LEN);
306 int32_t flags = GetData<int32_t>();
307 int32_t scope = GetData<int32_t>();
308
309 MessageParcel dataParcel;
310 if (!WriteInterfaceTokenCallback(dataParcel)) {
311 return;
312 }
313
314 dataParcel.WriteString(addr);
315 dataParcel.WriteString(ifName);
316 dataParcel.WriteInt32(flags);
317 dataParcel.WriteInt32(scope);
318 OnRemoteRequestCallBack(static_cast<uint32_t>(NetsysNative::NotifyInterfaceCode::ON_INTERFACE_ADDRESS_UPDATED),
319 dataParcel);
320 }
321
RegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)322 void RegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
323 {
324 MessageParcel dataParcel;
325 if (!IsDataAndSizeValid(data, size, dataParcel)) {
326 return;
327 }
328
329 sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) NetsysNative::NotifyCallbackTest();
330 notifyCb->Marshalling(dataParcel);
331 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_REGISTER_NOTIFY_CALLBACK),
332 dataParcel);
333 }
334
UnRegisterNotifyCallbackFuzzTest(const uint8_t * data,size_t size)335 void UnRegisterNotifyCallbackFuzzTest(const uint8_t *data, size_t size)
336 {
337 MessageParcel dataParcel;
338 if (!IsDataAndSizeValid(data, size, dataParcel)) {
339 return;
340 }
341
342 sptr<NetsysNative::NotifyCallbackStub> notifyCb = new (std::nothrow) NetsysNative::NotifyCallbackTest();
343
344 notifyCb->Marshalling(dataParcel);
345 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_UNREGISTER_NOTIFY_CALLBACK),
346 dataParcel);
347 }
348
InterfaceSetIffUpFuzzTest(const uint8_t * data,size_t size)349 void InterfaceSetIffUpFuzzTest(const uint8_t *data, size_t size)
350 {
351 MessageParcel dataParcel;
352 if (!IsDataAndSizeValid(data, size, dataParcel)) {
353 return;
354 }
355
356 std::string ifaceName = GetStringFromData(STR_LEN);
357
358 if (!dataParcel.WriteString("-L -n")) {
359 return;
360 }
361
362 dataParcel.WriteString(ifaceName);
363 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IFF_UP), dataParcel);
364 }
365
GetAddrInfoFuzzTest(const uint8_t * data,size_t size)366 void GetAddrInfoFuzzTest(const uint8_t *data, size_t size)
367 {
368 MessageParcel dataParcel;
369 if (!IsDataAndSizeValid(data, size, dataParcel)) {
370 return;
371 }
372
373 std::string hostName = GetStringFromData(STR_LEN);
374 std::string serverName = GetStringFromData(STR_LEN);
375 AddrInfo hints;
376 hints.aiFlags = GetData<uint32_t>();
377 hints.aiFamily = GetData<uint32_t>();
378 hints.aiSockType = GetData<uint32_t>();
379 hints.aiProtocol = GetData<uint32_t>();
380 hints.aiAddrLen = GetData<uint32_t>();
381
382 std::string aiCanName = GetStringFromData(STR_LEN);
383 if (memcpy_s(hints.aiCanonName, sizeof(hints.aiCanonName), aiCanName.c_str(), aiCanName.length()) != 0) {
384 return;
385 }
386 uint16_t netId = GetData<uint16_t>();
387
388 dataParcel.WriteString(hostName);
389 dataParcel.WriteString(serverName);
390 dataParcel.WriteRawData(&hints, sizeof(AddrInfo));
391 dataParcel.WriteUint16(netId);
392 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ADDR_INFO), dataParcel);
393 }
394
NetworkAddRouteParcelFuzzTest(const uint8_t * data,size_t size)395 void NetworkAddRouteParcelFuzzTest(const uint8_t *data, size_t size)
396 {
397 MessageParcel dataParcel;
398 if (!IsDataAndSizeValid(data, size, dataParcel)) {
399 return;
400 }
401
402 int32_t netId = GetData<int32_t>();
403 NetsysNative::RouteInfoParcel routInfo;
404 routInfo.destination = GetStringFromData(STR_LEN);
405 routInfo.ifName = GetStringFromData(STR_LEN);
406 routInfo.nextHop = GetStringFromData(STR_LEN);
407 routInfo.mtu = GetData<int32_t>();
408
409 dataParcel.WriteInt32(netId);
410 dataParcel.WriteString(routInfo.destination);
411 dataParcel.WriteString(routInfo.ifName);
412 dataParcel.WriteString(routInfo.nextHop);
413 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_ROUTE_PARCEL),
414 dataParcel);
415 }
416
NetworkRemoveRouteParcelFuzzTest(const uint8_t * data,size_t size)417 void NetworkRemoveRouteParcelFuzzTest(const uint8_t *data, size_t size)
418 {
419 MessageParcel dataParcel;
420 if (!IsDataAndSizeValid(data, size, dataParcel)) {
421 return;
422 }
423
424 int32_t netId = GetData<int32_t>();
425 NetsysNative::RouteInfoParcel routInfo;
426 routInfo.destination = GetStringFromData(STR_LEN);
427 routInfo.ifName = GetStringFromData(STR_LEN);
428 routInfo.nextHop = GetStringFromData(STR_LEN);
429
430 dataParcel.WriteInt32(netId);
431 dataParcel.WriteString(routInfo.destination);
432 dataParcel.WriteString(routInfo.ifName);
433 dataParcel.WriteString(routInfo.nextHop);
434 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_REMOVE_ROUTE_PARCEL),
435 dataParcel);
436 }
437
NetworkSetDefaultFuzzTest(const uint8_t * data,size_t size)438 void NetworkSetDefaultFuzzTest(const uint8_t *data, size_t size)
439 {
440 MessageParcel dataParcel;
441 if (!IsDataAndSizeValid(data, size, dataParcel)) {
442 return;
443 }
444
445 int32_t netId = GetData<int32_t>();
446
447 dataParcel.WriteInt32(netId);
448 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_SET_DEFAULT), dataParcel);
449 }
450
NetworkGetDefaultFuzzTest(const uint8_t * data,size_t size)451 void NetworkGetDefaultFuzzTest(const uint8_t *data, size_t size)
452 {
453 MessageParcel dataParcel;
454 if (!IsDataAndSizeValid(data, size, dataParcel)) {
455 return;
456 }
457 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_GET_DEFAULT), dataParcel);
458 }
SetDefaultNetWorkFuzzTest(const uint8_t * data,size_t size)459 void SetDefaultNetWorkFuzzTest(const uint8_t *data, size_t size)
460 {
461 MessageParcel dataParcel;
462 if (!IsDataAndSizeValid(data, size, dataParcel)) {
463 return;
464 }
465
466 int32_t netId = GetData<int32_t>();
467
468 dataParcel.WriteInt32(netId);
469 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_SET_DEFAULT), dataParcel);
470 }
471
IpfwdAddInterfaceForwardFuzzTest(const uint8_t * data,size_t size)472 void IpfwdAddInterfaceForwardFuzzTest(const uint8_t *data, size_t size)
473 {
474 MessageParcel dataParcel;
475 if (!IsDataAndSizeValid(data, size, dataParcel)) {
476 return;
477 }
478
479 std::string fromIface = GetStringFromData(STR_LEN);
480 std::string toIface = GetStringFromData(STR_LEN);
481
482 dataParcel.WriteString(fromIface);
483 dataParcel.WriteString(toIface);
484 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_ADD_INTERFACE_FORWARD),
485 dataParcel);
486 }
487
IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t * data,size_t size)488 void IpfwdRemoveInterfaceForwardFuzzTest(const uint8_t *data, size_t size)
489 {
490 MessageParcel dataParcel;
491 if (!IsDataAndSizeValid(data, size, dataParcel)) {
492 return;
493 }
494
495 std::string fromIface = GetStringFromData(STR_LEN);
496 std::string toIface = GetStringFromData(STR_LEN);
497
498 dataParcel.WriteString(fromIface);
499 dataParcel.WriteString(toIface);
500 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPFWD_REMOVE_INTERFACE_FORWARD),
501 dataParcel);
502 }
503
InterfaceSetIpAddressFuzzTest(const uint8_t * data,size_t size)504 void InterfaceSetIpAddressFuzzTest(const uint8_t *data, size_t size)
505 {
506 MessageParcel dataParcel;
507 if (!IsDataAndSizeValid(data, size, dataParcel)) {
508 return;
509 }
510
511 std::string ifaceName = GetStringFromData(STR_LEN);
512 std::string ipAddress = GetStringFromData(STR_LEN);
513
514 dataParcel.WriteString(ifaceName);
515 dataParcel.WriteString(ipAddress);
516 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_IP_ADDRESS),
517 dataParcel);
518 }
519
FirewallSetUidsAllowedListChainFuzzTest(const uint8_t * data,size_t size)520 void FirewallSetUidsAllowedListChainFuzzTest(const uint8_t *data, size_t size)
521 {
522 MessageParcel dataParcel;
523 if (!IsDataAndSizeValid(data, size, dataParcel)) {
524 return;
525 }
526
527 auto chain = GetData<uint32_t>();
528 auto uidSize = static_cast<uint32_t>(GetData<uint8_t>());
529
530 dataParcel.WriteUint32(chain);
531 dataParcel.WriteUint32(uidSize);
532 for (uint32_t index = 0; index < uidSize; index++) {
533 dataParcel.WriteUint32(GetData<uint32_t>());
534 }
535 OnRemoteRequest(
536 static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_ALLOWED_LIST_CHAIN),
537 dataParcel);
538 }
539
FirewallSetUidsDeniedListChainFuzzTest(const uint8_t * data,size_t size)540 void FirewallSetUidsDeniedListChainFuzzTest(const uint8_t *data, size_t size)
541 {
542 MessageParcel dataParcel;
543 if (!IsDataAndSizeValid(data, size, dataParcel)) {
544 return;
545 }
546
547 auto chain = GetData<uint32_t>();
548 auto uidSize = static_cast<uint32_t>(GetData<uint8_t>());
549
550 dataParcel.WriteUint32(chain);
551 dataParcel.WriteUint32(uidSize);
552 for (uint32_t index = 0; index < uidSize; index++) {
553 dataParcel.WriteUint32(GetData<uint32_t>());
554 }
555 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_DENIED_LIST_CHAIN),
556 dataParcel);
557 }
558
FirewallSetUidRuleFuzzTest(const uint8_t * data,size_t size)559 void FirewallSetUidRuleFuzzTest(const uint8_t *data, size_t size)
560 {
561 MessageParcel dataParcel;
562 if (!IsDataAndSizeValid(data, size, dataParcel)) {
563 return;
564 }
565
566 int32_t chain = GetData<int32_t>();
567 int32_t firewallRule = GetData<int32_t>();
568
569 dataParcel.WriteInt32(chain);
570 uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
571 dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
572 for (uint32_t i = 0; i <= vectorLength; i++) {
573 dataParcel.WriteInt32(GetData<uint32_t>());
574 }
575
576 dataParcel.WriteInt32(firewallRule);
577
578 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_SET_UID_RULE), dataParcel);
579 }
SetInterfaceConfigFuzzTest(const uint8_t * data,size_t size)580 void SetInterfaceConfigFuzzTest(const uint8_t *data, size_t size)
581 {
582 MessageParcel dataParcel;
583 if (!IsDataAndSizeValid(data, size, dataParcel)) {
584 return;
585 }
586
587 OHOS::nmd::InterfaceConfigurationParcel cfg;
588 cfg.ifName = GetStringFromData(STR_LEN);
589 cfg.hwAddr = GetStringFromData(STR_LEN);
590 cfg.ipv4Addr = GetStringFromData(STR_LEN);
591 cfg.prefixLength = GetData<int32_t>();
592
593 dataParcel.WriteString(cfg.ifName);
594 dataParcel.WriteString(cfg.hwAddr);
595 dataParcel.WriteString(cfg.ipv4Addr);
596 dataParcel.WriteInt32(cfg.prefixLength);
597 uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
598 dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
599 for (uint32_t i = 0; i <= vectorLength; i++) {
600 dataParcel.WriteString(GetStringFromData(STR_LEN));
601 }
602
603 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_SET_CONFIG), dataParcel);
604 }
605
NetworkClearDefaultFuzzTest(const uint8_t * data,size_t size)606 void NetworkClearDefaultFuzzTest(const uint8_t *data, size_t size)
607 {
608 MessageParcel dataParcel;
609 if (!IsDataAndSizeValid(data, size, dataParcel)) {
610 return;
611 }
612 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CLEAR_DEFAULT), dataParcel);
613 }
614
GetProcSysNetFuzzTest(const uint8_t * data,size_t size)615 void GetProcSysNetFuzzTest(const uint8_t *data, size_t size)
616 {
617 MessageParcel dataParcel;
618 if (!IsDataAndSizeValid(data, size, dataParcel)) {
619 return;
620 }
621
622 int32_t family = GetData<int32_t>();
623 int32_t which = GetData<int32_t>();
624 std::string ifname = GetStringFromData(STR_LEN);
625 std::string parameter = GetStringFromData(STR_LEN);
626
627 dataParcel.WriteInt32(family);
628 dataParcel.WriteInt32(which);
629 dataParcel.WriteString(ifname);
630 dataParcel.WriteString(parameter);
631 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_PROC_SYS_NET), dataParcel);
632 }
633
SetProcSysNetFuzzTest(const uint8_t * data,size_t size)634 void SetProcSysNetFuzzTest(const uint8_t *data, size_t size)
635 {
636 MessageParcel dataParcel;
637 if (!IsDataAndSizeValid(data, size, dataParcel)) {
638 return;
639 }
640
641 int32_t family = GetData<int32_t>();
642 int32_t which = GetData<int32_t>();
643 std::string ifname = GetStringFromData(STR_LEN);
644 std::string parameter = GetStringFromData(STR_LEN);
645 std::string value = GetStringFromData(STR_LEN);
646
647 dataParcel.WriteInt32(family);
648 dataParcel.WriteInt32(which);
649 dataParcel.WriteString(ifname);
650 dataParcel.WriteString(parameter);
651 dataParcel.WriteString(value);
652 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_PROC_SYS_NET), dataParcel);
653 }
654
SetInternetPermissionFuzzTest(const uint8_t * data,size_t size)655 void SetInternetPermissionFuzzTest(const uint8_t *data, size_t size)
656 {
657 MessageParcel dataParcel;
658 if (!IsDataAndSizeValid(data, size, dataParcel)) {
659 return;
660 }
661
662 uint32_t uid = GetData<uint32_t>();
663 int8_t allow = GetData<int8_t>();
664
665 dataParcel.WriteUint32(uid);
666 dataParcel.WriteInt8(allow);
667 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_INTERNET_PERMISSION),
668 dataParcel);
669 }
670
GetFwmarkForNetworkFuzzTest(const uint8_t * data,size_t size)671 void GetFwmarkForNetworkFuzzTest(const uint8_t *data, size_t size)
672 {
673 MessageParcel dataParcel;
674 if (!IsDataAndSizeValid(data, size, dataParcel)) {
675 return;
676 }
677
678 int32_t netId = GetData<int32_t>();
679 NetsysNative::MarkMaskParcel markParcl;
680 markParcl.mark = GetData<int32_t>();
681 markParcl.mask = GetData<int32_t>();
682
683 dataParcel.WriteInt32(netId);
684 dataParcel.WriteInt32(markParcl.mark);
685 dataParcel.WriteInt32(markParcl.mask);
686 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_FWMARK_FOR_NETWORK),
687 dataParcel);
688 }
689
IpEnableForwardingFuzzTest(const uint8_t * data,size_t size)690 void IpEnableForwardingFuzzTest(const uint8_t *data, size_t size)
691 {
692 MessageParcel dataParcel;
693 if (!IsDataAndSizeValid(data, size, dataParcel)) {
694 return;
695 }
696
697 std::string requestor = GetStringFromData(STR_LEN);
698
699 dataParcel.WriteString(requestor);
700 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPENABLE_FORWARDING), dataParcel);
701 }
702
IpDisableForwardingFuzzTest(const uint8_t * data,size_t size)703 void IpDisableForwardingFuzzTest(const uint8_t *data, size_t size)
704 {
705 MessageParcel dataParcel;
706 if (!IsDataAndSizeValid(data, size, dataParcel)) {
707 return;
708 }
709
710 std::string requestor = GetStringFromData(STR_LEN);
711
712 dataParcel.WriteString(requestor);
713 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_IPDISABLE_FORWARDING), dataParcel);
714 }
715
EnableNatFuzzTest(const uint8_t * data,size_t size)716 void EnableNatFuzzTest(const uint8_t *data, size_t size)
717 {
718 MessageParcel dataParcel;
719 if (!IsDataAndSizeValid(data, size, dataParcel)) {
720 return;
721 }
722
723 std::string downstreamIface = GetStringFromData(STR_LEN);
724 std::string upstreamIface = GetStringFromData(STR_LEN);
725
726 dataParcel.WriteString(downstreamIface);
727 dataParcel.WriteString(upstreamIface);
728 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_ENABLE_NAT), dataParcel);
729 }
730
DisableNatFuzzTest(const uint8_t * data,size_t size)731 void DisableNatFuzzTest(const uint8_t *data, size_t size)
732 {
733 MessageParcel dataParcel;
734 if (!IsDataAndSizeValid(data, size, dataParcel)) {
735 return;
736 }
737
738 std::string downstreamIface = GetStringFromData(STR_LEN);
739 std::string upstreamIface = GetStringFromData(STR_LEN);
740
741 dataParcel.WriteString(downstreamIface);
742 dataParcel.WriteString(upstreamIface);
743 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DISABLE_NAT), dataParcel);
744 }
745
BandwidthEnableDataSaverFuzzTest(const uint8_t * data,size_t size)746 void BandwidthEnableDataSaverFuzzTest(const uint8_t *data, size_t size)
747 {
748 MessageParcel dataParcel;
749 if (!IsDataAndSizeValid(data, size, dataParcel)) {
750 return;
751 }
752
753 bool enable = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
754
755 dataParcel.WriteBool(enable);
756 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ENABLE_DATA_SAVER),
757 dataParcel);
758 }
759
BandwidthSetIfaceQuotaFuzzTest(const uint8_t * data,size_t size)760 void BandwidthSetIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
761 {
762 MessageParcel dataParcel;
763 if (!IsDataAndSizeValid(data, size, dataParcel)) {
764 return;
765 }
766
767 int64_t bytes = GetData<int64_t>();
768 std::string ifName = GetStringFromData(STR_LEN);
769
770 dataParcel.WriteString(ifName);
771 dataParcel.WriteInt64(bytes);
772 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_SET_IFACE_QUOTA),
773 dataParcel);
774 }
775
BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t * data,size_t size)776 void BandwidthRemoveIfaceQuotaFuzzTest(const uint8_t *data, size_t size)
777 {
778 MessageParcel dataParcel;
779 if (!IsDataAndSizeValid(data, size, dataParcel)) {
780 return;
781 }
782
783 std::string ifName = GetStringFromData(STR_LEN);
784
785 dataParcel.WriteString(ifName);
786 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_IFACE_QUOTA),
787 dataParcel);
788 }
789
BandwidthAddDeniedListFuzzTest(const uint8_t * data,size_t size)790 void BandwidthAddDeniedListFuzzTest(const uint8_t *data, size_t size)
791 {
792 MessageParcel dataParcel;
793 if (!IsDataAndSizeValid(data, size, dataParcel)) {
794 return;
795 }
796
797 uint32_t uid = GetData<uint32_t>();
798
799 dataParcel.WriteInt32(uid);
800 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_DENIED_LIST),
801 dataParcel);
802 }
803
BandwidthRemoveDeniedListFuzzTest(const uint8_t * data,size_t size)804 void BandwidthRemoveDeniedListFuzzTest(const uint8_t *data, size_t size)
805 {
806 MessageParcel dataParcel;
807 if (!IsDataAndSizeValid(data, size, dataParcel)) {
808 return;
809 }
810
811 uint32_t uid = GetData<uint32_t>();
812
813 dataParcel.WriteInt32(uid);
814 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_DENIED_LIST),
815 dataParcel);
816 }
817
BandwidthAddAllowedListFuzzTest(const uint8_t * data,size_t size)818 void BandwidthAddAllowedListFuzzTest(const uint8_t *data, size_t size)
819 {
820 MessageParcel dataParcel;
821 if (!IsDataAndSizeValid(data, size, dataParcel)) {
822 return;
823 }
824
825 uint32_t uid = GetData<uint32_t>();
826
827 dataParcel.WriteInt32(uid);
828 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_ADD_ALLOWED_LIST),
829 dataParcel);
830 }
831
BandwidthRemoveAllowedListFuzzTest(const uint8_t * data,size_t size)832 void BandwidthRemoveAllowedListFuzzTest(const uint8_t *data, size_t size)
833 {
834 MessageParcel dataParcel;
835 if (!IsDataAndSizeValid(data, size, dataParcel)) {
836 return;
837 }
838
839 uint32_t uid = GetData<uint32_t>();
840
841 dataParcel.WriteInt32(uid);
842 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_BANDWIDTH_REMOVE_ALLOWED_LIST),
843 dataParcel);
844 }
845
FirewallEnableChainFuzzTest(const uint8_t * data,size_t size)846 void FirewallEnableChainFuzzTest(const uint8_t *data, size_t size)
847 {
848 MessageParcel dataParcel;
849 if (!IsDataAndSizeValid(data, size, dataParcel)) {
850 return;
851 }
852
853 uint32_t chain = GetData<uint32_t>();
854 bool enable = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
855
856 dataParcel.WriteInt32(chain);
857 dataParcel.WriteBool(enable);
858 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_FIREWALL_ENABLE_CHAIN), dataParcel);
859 }
860
GetNetworkSharingTrafficFuzzTest(const uint8_t * data,size_t size)861 void GetNetworkSharingTrafficFuzzTest(const uint8_t *data, size_t size)
862 {
863 MessageParcel dataParcel;
864 if (!IsDataAndSizeValid(data, size, dataParcel)) {
865 return;
866 }
867
868 std::string downIface = GetStringFromData(STR_LEN);
869 std::string upIface = GetStringFromData(STR_LEN);
870
871 dataParcel.WriteString(downIface);
872 dataParcel.WriteString(upIface);
873 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_SHARING_NETWORK_TRAFFIC),
874 dataParcel);
875 }
876
DelInterfaceAddressFuzzTest(const uint8_t * data,size_t size)877 void DelInterfaceAddressFuzzTest(const uint8_t *data, size_t size)
878 {
879 MessageParcel dataParcel;
880 if (!IsDataAndSizeValid(data, size, dataParcel)) {
881 return;
882 }
883
884 std::string interfaceName = GetStringFromData(STR_LEN);
885 std::string ipAddr = GetStringFromData(STR_LEN);
886 int32_t prefixLength = GetData<int32_t>();
887
888 dataParcel.WriteString(interfaceName);
889 dataParcel.WriteString(ipAddr);
890 dataParcel.WriteInt32(prefixLength);
891 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_DEL_ADDRESS), dataParcel);
892 }
893
SetResolverConfigFuzzTest(const uint8_t * data,size_t size)894 void SetResolverConfigFuzzTest(const uint8_t *data, size_t size)
895 {
896 MessageParcel dataParcel;
897 if (!IsDataAndSizeValid(data, size, dataParcel)) {
898 return;
899 }
900
901 uint16_t netId = GetData<uint16_t>();
902 uint16_t baseTimeoutMsec = GetData<uint16_t>();
903 uint8_t retryCount = GetData<uint8_t>();
904
905 dataParcel.WriteUint16(netId);
906 dataParcel.WriteUint16(baseTimeoutMsec);
907 dataParcel.WriteUint8(retryCount);
908
909 uint32_t vectorLength = GetData<uint32_t>() % VECTOR_MAX_SIZE;
910 dataParcel.WriteInt32(static_cast<int32_t>(vectorLength));
911 for (uint32_t i = 0; i <= vectorLength; i++) {
912 dataParcel.WriteString(GetStringFromData(STR_LEN));
913 }
914
915 uint32_t vectorLength2 = GetData<uint32_t>() % VECTOR_MAX_SIZE;
916 dataParcel.WriteInt32(static_cast<int32_t>(vectorLength2));
917 for (uint32_t i = 0; i <= vectorLength2; i++) {
918 dataParcel.WriteString(GetStringFromData(STR_LEN));
919 }
920 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_RESOLVER_CONFIG), dataParcel);
921 }
922
GetResolverConfigFuzzTest(const uint8_t * data,size_t size)923 void GetResolverConfigFuzzTest(const uint8_t *data, size_t size)
924 {
925 MessageParcel dataParcel;
926 if (!IsDataAndSizeValid(data, size, dataParcel)) {
927 return;
928 }
929
930 uint16_t netId = GetData<uint16_t>();
931
932 dataParcel.WriteUint16(netId);
933 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_RESOLVER_CONFIG), dataParcel);
934 }
935
CreateNetworkCacheFuzzTest(const uint8_t * data,size_t size)936 void CreateNetworkCacheFuzzTest(const uint8_t *data, size_t size)
937 {
938 MessageParcel dataParcel;
939 if (!IsDataAndSizeValid(data, size, dataParcel)) {
940 return;
941 }
942
943 uint16_t netId = GetData<uint16_t>();
944
945 dataParcel.WriteUint16(netId);
946 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_CREATE_NETWORK_CACHE), dataParcel);
947 }
948
DestroyNetworkCacheFuzzTest(const uint8_t * data,size_t size)949 void DestroyNetworkCacheFuzzTest(const uint8_t *data, size_t size)
950 {
951 MessageParcel dataParcel;
952 if (!IsDataAndSizeValid(data, size, dataParcel)) {
953 return;
954 }
955
956 uint16_t netId = GetData<uint16_t>();
957
958 dataParcel.WriteUint16(netId);
959 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_DESTROY_NETWORK_CACHE), dataParcel);
960 }
961
InterfaceGetListFuzzTest(const uint8_t * data,size_t size)962 void InterfaceGetListFuzzTest(const uint8_t *data, size_t size)
963 {
964 MessageParcel dataParcel;
965 if (!IsDataAndSizeValid(data, size, dataParcel)) {
966 return;
967 }
968 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_INTERFACE_GET_LIST), dataParcel);
969 }
970
ShareDnsSetFuzzTest(const uint8_t * data,size_t size)971 void ShareDnsSetFuzzTest(const uint8_t *data, size_t size)
972 {
973 MessageParcel dataParcel;
974 if (!IsDataAndSizeValid(data, size, dataParcel)) {
975 return;
976 }
977 uint16_t netId = GetData<uint16_t>();
978 dataParcel.WriteUint16(netId);
979 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_TETHER_DNS_SET), dataParcel);
980 }
981
StartDnsProxyListenFuzzTest(const uint8_t * data,size_t size)982 void StartDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
983 {
984 MessageParcel dataParcel;
985 if (!IsDataAndSizeValid(data, size, dataParcel)) {
986 return;
987 }
988 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DNS_PROXY_LISTEN),
989 dataParcel);
990 }
991
StopDnsProxyListenFuzzTest(const uint8_t * data,size_t size)992 void StopDnsProxyListenFuzzTest(const uint8_t *data, size_t size)
993 {
994 MessageParcel dataParcel;
995 if (!IsDataAndSizeValid(data, size, dataParcel)) {
996 return;
997 }
998 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DNS_PROXY_LISTEN), dataParcel);
999 }
1000
StartDhcpClientFuzzTest(const uint8_t * data,size_t size)1001 void StartDhcpClientFuzzTest(const uint8_t *data, size_t size)
1002 {
1003 MessageParcel dataParcel;
1004 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1005 return;
1006 }
1007 std::string iface = GetStringFromData(STR_LEN);
1008 bool bIpv6 = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1009 dataParcel.WriteString(iface);
1010 dataParcel.WriteBool(bIpv6);
1011 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_CLIENT), dataParcel);
1012 }
1013
StopDhcpClientFuzzTest(const uint8_t * data,size_t size)1014 void StopDhcpClientFuzzTest(const uint8_t *data, size_t size)
1015 {
1016 MessageParcel dataParcel;
1017 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1018 return;
1019 }
1020 std::string iface = GetStringFromData(STR_LEN);
1021 bool bIpv6 = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
1022
1023 dataParcel.WriteString(iface);
1024 dataParcel.WriteBool(bIpv6);
1025 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_CLIENT), dataParcel);
1026 }
1027
StartDhcpServiceFuzzTest(const uint8_t * data,size_t size)1028 void StartDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1029 {
1030 MessageParcel dataParcel;
1031 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1032 return;
1033 }
1034 std::string iface = GetStringFromData(STR_LEN);
1035 std::string ipv4addr = GetStringFromData(STR_LEN);
1036 dataParcel.WriteString(iface);
1037 dataParcel.WriteString(ipv4addr);
1038 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_START_DHCP_SERVICE), dataParcel);
1039 }
1040
StopDhcpServiceFuzzTest(const uint8_t * data,size_t size)1041 void StopDhcpServiceFuzzTest(const uint8_t *data, size_t size)
1042 {
1043 MessageParcel dataParcel;
1044 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1045 return;
1046 }
1047 std::string iface = GetStringFromData(STR_LEN);
1048 dataParcel.WriteString(iface);
1049 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_STOP_DHCP_SERVICE), dataParcel);
1050 }
1051
GetTotalStatsFuzzTest(const uint8_t * data,size_t size)1052 void GetTotalStatsFuzzTest(const uint8_t *data, size_t size)
1053 {
1054 MessageParcel dataParcel;
1055 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1056 return;
1057 }
1058
1059 uint32_t type = GetData<uint32_t>();
1060 dataParcel.WriteUint32(type);
1061 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_TOTAL_STATS), dataParcel);
1062 }
1063
GetUidStatsFuzzTest(const uint8_t * data,size_t size)1064 void GetUidStatsFuzzTest(const uint8_t *data, size_t size)
1065 {
1066 MessageParcel dataParcel;
1067 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1068 return;
1069 }
1070 uint32_t type = GetData<uint32_t>();
1071 uint32_t uid = GetData<uint32_t>();
1072
1073 dataParcel.WriteUint32(type);
1074 dataParcel.WriteUint32(uid);
1075 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_UID_STATS), dataParcel);
1076 }
1077
GetIfaceStatsFuzzTest(const uint8_t * data,size_t size)1078 void GetIfaceStatsFuzzTest(const uint8_t *data, size_t size)
1079 {
1080 MessageParcel dataParcel;
1081 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1082 return;
1083 }
1084 uint32_t type = GetData<uint32_t>();
1085 std::string iface = GetStringFromData(STR_LEN);
1086
1087 dataParcel.WriteUint32(type);
1088 dataParcel.WriteString(iface);
1089 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_IFACE_STATS), dataParcel);
1090 }
1091
GetAllStatsInfoFuzzTest(const uint8_t * data,size_t size)1092 void GetAllStatsInfoFuzzTest(const uint8_t *data, size_t size)
1093 {
1094 MessageParcel dataParcel;
1095 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1096 return;
1097 }
1098
1099 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_ALL_STATS_INFO), dataParcel);
1100 }
1101
SetIptablesCommandForResFuzzTest(const uint8_t * data,size_t size)1102 void SetIptablesCommandForResFuzzTest(const uint8_t *data, size_t size)
1103 {
1104 MessageParcel dataParcel;
1105 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1106 return;
1107 }
1108 if (!dataParcel.WriteString("-L -n")) {
1109 return;
1110 }
1111
1112 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_SET_IPTABLES_CMD_FOR_RES),
1113 dataParcel);
1114 }
1115
NetworkCreateVirtualFuzzTest(const uint8_t * data,size_t size)1116 void NetworkCreateVirtualFuzzTest(const uint8_t *data, size_t size)
1117 {
1118 MessageParcel dataParcel;
1119 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1120 return;
1121 }
1122
1123 int32_t netId = GetData<int32_t>();
1124 bool hasDns = GetData<bool>();
1125
1126 dataParcel.WriteInt32(netId);
1127 dataParcel.WriteBool(hasDns);
1128
1129 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_CREATE_VIRTUAL),
1130 dataParcel);
1131 }
1132
NetworkAddUidsFuzzTest(const uint8_t * data,size_t size)1133 void NetworkAddUidsFuzzTest(const uint8_t *data, size_t size)
1134 {
1135 MessageParcel dataParcel;
1136 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1137 return;
1138 }
1139
1140 int32_t netId = GetData<int32_t>();
1141 std::vector<UidRange> uidRanges;
1142 UidRange uid;
1143 int32_t rangesSize = GetData<int32_t>() % VECTOR_MAX_SIZE;
1144 for (int i = 0; i < rangesSize; i++) {
1145 uidRanges.emplace_back(uid);
1146 }
1147
1148 dataParcel.WriteInt32(netId);
1149 dataParcel.WriteInt32(rangesSize);
1150 for (auto iter : uidRanges) {
1151 iter.Marshalling(dataParcel);
1152 }
1153
1154 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_ADD_UIDS), dataParcel);
1155 }
1156
NetworkDelUidsFuzzTest(const uint8_t * data,size_t size)1157 void NetworkDelUidsFuzzTest(const uint8_t *data, size_t size)
1158 {
1159 MessageParcel dataParcel;
1160 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1161 return;
1162 }
1163
1164 int32_t netId = GetData<int32_t>();
1165 std::vector<UidRange> uidRanges;
1166 UidRange uid;
1167 int32_t rangesSize = GetData<int32_t>() % VECTOR_MAX_SIZE;
1168 for (int i = 0; i < rangesSize; i++) {
1169 uidRanges.emplace_back(uid);
1170 }
1171
1172 dataParcel.WriteInt32(netId);
1173 dataParcel.WriteInt32(rangesSize);
1174 for (auto iter : uidRanges) {
1175 iter.Marshalling(dataParcel);
1176 }
1177
1178 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_NETWORK_DEL_UIDS), dataParcel);
1179 }
1180
GetCookieStatsFuzzTest(const uint8_t * data,size_t size)1181 void GetCookieStatsFuzzTest(const uint8_t *data, size_t size)
1182 {
1183 MessageParcel dataParcel;
1184 if (!IsDataAndSizeValid(data, size, dataParcel)) {
1185 return;
1186 }
1187 uint32_t type = GetData<uint32_t>();
1188 uint64_t cookie = GetData<uint64_t>();
1189
1190 dataParcel.WriteUint32(type);
1191 dataParcel.WriteUint32(cookie);
1192 OnRemoteRequest(static_cast<uint32_t>(NetsysNative::NetsysInterfaceCode::NETSYS_GET_COOKIE_STATS), dataParcel);
1193 }
1194
LLVMFuzzerTestOneInputNew(const uint8_t * data,size_t size)1195 void LLVMFuzzerTestOneInputNew(const uint8_t *data, size_t size)
1196 {
1197 OHOS::NetManagerStandard::RegisterNotifyCallbackFuzzTest(data, size);
1198 OHOS::NetManagerStandard::UnRegisterNotifyCallbackFuzzTest(data, size);
1199 OHOS::NetManagerStandard::InterfaceSetIffUpFuzzTest(data, size);
1200 OHOS::NetManagerStandard::GetAddrInfoFuzzTest(data, size);
1201 OHOS::NetManagerStandard::NetworkAddRouteParcelFuzzTest(data, size);
1202 OHOS::NetManagerStandard::NetworkSetDefaultFuzzTest(data, size);
1203 OHOS::NetManagerStandard::NetworkGetDefaultFuzzTest(data, size);
1204 OHOS::NetManagerStandard::NetworkClearDefaultFuzzTest(data, size);
1205 OHOS::NetManagerStandard::GetProcSysNetFuzzTest(data, size);
1206 OHOS::NetManagerStandard::SetProcSysNetFuzzTest(data, size);
1207 OHOS::NetManagerStandard::SetInternetPermissionFuzzTest(data, size);
1208 OHOS::NetManagerStandard::GetFwmarkForNetworkFuzzTest(data, size);
1209 OHOS::NetManagerStandard::IpEnableForwardingFuzzTest(data, size);
1210 OHOS::NetManagerStandard::IpDisableForwardingFuzzTest(data, size);
1211 OHOS::NetManagerStandard::EnableNatFuzzTest(data, size);
1212 OHOS::NetManagerStandard::DisableNatFuzzTest(data, size);
1213 OHOS::NetManagerStandard::BandwidthEnableDataSaverFuzzTest(data, size);
1214 OHOS::NetManagerStandard::BandwidthSetIfaceQuotaFuzzTest(data, size);
1215 OHOS::NetManagerStandard::BandwidthRemoveIfaceQuotaFuzzTest(data, size);
1216 OHOS::NetManagerStandard::BandwidthAddDeniedListFuzzTest(data, size);
1217 OHOS::NetManagerStandard::BandwidthRemoveDeniedListFuzzTest(data, size);
1218 OHOS::NetManagerStandard::BandwidthAddAllowedListFuzzTest(data, size);
1219 OHOS::NetManagerStandard::BandwidthRemoveAllowedListFuzzTest(data, size);
1220 OHOS::NetManagerStandard::FirewallEnableChainFuzzTest(data, size);
1221 OHOS::NetManagerStandard::GetNetworkSharingTrafficFuzzTest(data, size);
1222 OHOS::NetManagerStandard::NetworkCreateVirtualFuzzTest(data, size);
1223 OHOS::NetManagerStandard::NetworkAddUidsFuzzTest(data, size);
1224 OHOS::NetManagerStandard::NetworkDelUidsFuzzTest(data, size);
1225 OHOS::NetManagerStandard::GetIfaceStatsFuzzTest(data, size);
1226 OHOS::NetManagerStandard::GetUidStatsFuzzTest(data, size);
1227 OHOS::NetManagerStandard::NetworkRemoveRouteParcelFuzzTest(data, size);
1228 OHOS::NetManagerStandard::OnInterfaceAddressUpdatedFuzzTest(data, size);
1229 OHOS::NetManagerStandard::GetCookieStatsFuzzTest(data, size);
1230 }
1231 } // namespace NetManagerStandard
1232 } // namespace OHOS
1233
1234 /* Fuzzer entry point1 */
1235
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1236 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1237 {
1238 /* Run your code on data */
1239 OHOS::NetManagerStandard::NetworkCreatePhysicalFuzzTest(data, size);
1240 OHOS::NetManagerStandard::NetworkDestroyFuzzTest(data, size);
1241 OHOS::NetManagerStandard::NetworkAddInterfaceFuzzTest(data, size);
1242 OHOS::NetManagerStandard::NetworkRemoveInterfaceFuzzTest(data, size);
1243 OHOS::NetManagerStandard::NetworkAddRouteFuzzTest(data, size);
1244 OHOS::NetManagerStandard::NetworkRemoveRouteFuzzTest(data, size);
1245 OHOS::NetManagerStandard::GetInterfaceConfigFuzzTest(data, size);
1246 OHOS::NetManagerStandard::GetInterfaceMtuFuzzTest(data, size);
1247 OHOS::NetManagerStandard::SetInterfaceMtuFuzzTest(data, size);
1248 OHOS::NetManagerStandard::AddInterfaceAddressFuzzTest(data, size);
1249 OHOS::NetManagerStandard::DelInterfaceAddressFuzzTest(data, size);
1250 OHOS::NetManagerStandard::SetResolverConfigFuzzTest(data, size);
1251 OHOS::NetManagerStandard::GetResolverConfigFuzzTest(data, size);
1252 OHOS::NetManagerStandard::DestroyNetworkCacheFuzzTest(data, size);
1253 OHOS::NetManagerStandard::InterfaceGetListFuzzTest(data, size);
1254 OHOS::NetManagerStandard::ShareDnsSetFuzzTest(data, size);
1255 OHOS::NetManagerStandard::StartDnsProxyListenFuzzTest(data, size);
1256 OHOS::NetManagerStandard::StopDnsProxyListenFuzzTest(data, size);
1257 OHOS::NetManagerStandard::StartDhcpClientFuzzTest(data, size);
1258 OHOS::NetManagerStandard::StopDhcpClientFuzzTest(data, size);
1259 OHOS::NetManagerStandard::StartDhcpServiceFuzzTest(data, size);
1260 OHOS::NetManagerStandard::StopDhcpServiceFuzzTest(data, size);
1261 OHOS::NetManagerStandard::SetIptablesCommandForResFuzzTest(data, size);
1262 OHOS::NetManagerStandard::SetDefaultNetWorkFuzzTest(data, size);
1263 OHOS::NetManagerStandard::SetInterfaceConfigFuzzTest(data, size);
1264 OHOS::NetManagerStandard::IpfwdAddInterfaceForwardFuzzTest(data, size);
1265 OHOS::NetManagerStandard::IpfwdRemoveInterfaceForwardFuzzTest(data, size);
1266 OHOS::NetManagerStandard::InterfaceSetIpAddressFuzzTest(data, size);
1267 OHOS::NetManagerStandard::FirewallSetUidsAllowedListChainFuzzTest(data, size);
1268 OHOS::NetManagerStandard::FirewallSetUidsDeniedListChainFuzzTest(data, size);
1269 OHOS::NetManagerStandard::FirewallSetUidRuleFuzzTest(data, size);
1270 OHOS::NetManagerStandard::LLVMFuzzerTestOneInputNew(data, size);
1271 return 0;
1272 }