1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <thread>
17
18 #include <securec.h>
19
20 #include "singleton.h"
21
22 #include "i_net_policy_service.h"
23 #include "net_conn_service_iface.h"
24 #include "net_mgr_log_wrapper.h"
25 #include "net_policy_constants.h"
26 #include "net_policy_service_common.h"
27 #include "net_stats_info.h"
28 #define private public
29 #include "net_manager_center.h"
30
31 namespace OHOS {
32 namespace NetManagerStandard {
33 namespace {
34 const uint8_t *g_baseFuzzData = nullptr;
35 static constexpr uint32_t CREATE_NET_TYPE_VALUE = 7;
36 static constexpr uint32_t CONVERT_NUMBER_TO_BOOL = 2;
37 size_t g_baseFuzzSize = 0;
38 size_t g_baseFuzzPos;
39 constexpr size_t STR_LEN = 10;
40 } // namespace
41
GetData()42 template <class T> T GetData()
43 {
44 T object{};
45 size_t objectSize = sizeof(object);
46 if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
47 return object;
48 }
49 errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
50 if (ret != EOK) {
51 return {};
52 }
53 g_baseFuzzPos += objectSize;
54 return object;
55 }
56
GetStringFromData(int strlen)57 std::string GetStringFromData(int strlen)
58 {
59 char cstr[strlen];
60 cstr[strlen - 1] = '\0';
61 for (int i = 0; i < strlen - 1; i++) {
62 cstr[i] = GetData<char>();
63 }
64 std::string str(cstr);
65 return str;
66 }
67
68 static auto g_netManagerCenter = DelayedSingleton<NetManagerCenter>::GetInstance();
69
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)70 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
71 {
72 if ((data == nullptr) || (size == 0)) {
73 return;
74 }
75 g_baseFuzzData = data;
76 g_baseFuzzSize = size;
77 g_baseFuzzPos = 0;
78
79 uint32_t netType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
80 std::list<std::string> ifaceNames;
81 g_netManagerCenter->GetIfaceNames(static_cast<NetBearType>(netType), ifaceNames);
82 return;
83 }
84
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)85 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
86 {
87 if ((data == nullptr) || (size == 0)) {
88 return;
89 }
90 g_baseFuzzData = data;
91 g_baseFuzzSize = size;
92 g_baseFuzzPos = 0;
93
94 uint32_t bearerType = GetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
95 std::string ident = GetStringFromData(STR_LEN);
96 std::string ifaceName = GetStringFromData(STR_LEN);
97 g_netManagerCenter->GetIfaceNameByType(static_cast<NetBearType>(bearerType), ident, ifaceName);
98 }
99
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)100 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
101 {
102 if ((data == nullptr) || (size == 0)) {
103 return;
104 }
105 g_baseFuzzData = data;
106 g_baseFuzzSize = size;
107 g_baseFuzzPos = 0;
108 uint32_t supplierId = GetData<uint32_t>();
109 g_netManagerCenter->UnregisterNetSupplier(supplierId);
110 }
111
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)112 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
113 {
114 if ((data == nullptr) || (size == 0)) {
115 return;
116 }
117 g_baseFuzzData = data;
118 g_baseFuzzSize = size;
119 g_baseFuzzPos = 0;
120 uint32_t supplierId = GetData<uint32_t>();
121 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
122 if (netLinkInfo == nullptr) {
123 return;
124 }
125
126 g_netManagerCenter->UpdateNetLinkInfo(supplierId, netLinkInfo);
127 }
128
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)129 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
130 {
131 if ((data == nullptr) || (size == 0)) {
132 return;
133 }
134 g_baseFuzzData = data;
135 g_baseFuzzSize = size;
136 g_baseFuzzPos = 0;
137 uint32_t supplierId = GetData<uint32_t>();
138 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
139 if (netSupplierInfo == nullptr) {
140 return;
141 }
142 g_netManagerCenter->UpdateNetSupplierInfo(supplierId, netSupplierInfo);
143 }
144
RegisterConnServiceFuzzTest(const uint8_t * data,size_t size)145 void RegisterConnServiceFuzzTest(const uint8_t *data, size_t size)
146 {
147 if ((data == nullptr) || (size == 0)) {
148 return;
149 }
150 g_baseFuzzData = data;
151 g_baseFuzzSize = size;
152 g_baseFuzzPos = 0;
153 sptr<NetConnServiceIface> serviceIface = new (std::nothrow) NetConnServiceIface();
154 if (serviceIface == nullptr) {
155 return;
156 }
157 g_netManagerCenter->RegisterConnService(serviceIface);
158 }
159
GetIfaceStatsDetailFuzzTest(const uint8_t * data,size_t size)160 void GetIfaceStatsDetailFuzzTest(const uint8_t *data, size_t size)
161 {
162 if ((data == nullptr) || (size == 0)) {
163 return;
164 }
165 g_baseFuzzData = data;
166 g_baseFuzzSize = size;
167 g_baseFuzzPos = 0;
168
169 std::string iface = GetStringFromData(STR_LEN);
170 uint32_t start = GetData<uint32_t>();
171 uint32_t end = GetData<uint32_t>() + start;
172 NetStatsInfo info;
173 g_netManagerCenter->GetIfaceStatsDetail(iface, start, end, info);
174 }
175
ResetStatsFactoryFuzzTest(const uint8_t * data,size_t size)176 void ResetStatsFactoryFuzzTest(const uint8_t *data, size_t size)
177 {
178 if ((data == nullptr) || (size == 0)) {
179 return;
180 }
181 g_baseFuzzData = data;
182 g_baseFuzzSize = size;
183 g_baseFuzzPos = 0;
184
185 g_netManagerCenter->ResetStatsFactory();
186 }
187
RegisterStatsServiceFuzzTest(const uint8_t * data,size_t size)188 void RegisterStatsServiceFuzzTest(const uint8_t *data, size_t size)
189 {
190 if ((data == nullptr) || (size == 0)) {
191 return;
192 }
193 g_baseFuzzData = data;
194 g_baseFuzzSize = size;
195 g_baseFuzzPos = 0;
196 sptr<NetStatsBaseService> service = nullptr;
197
198 g_netManagerCenter->RegisterStatsService(service);
199 }
200
ResetPolicyFactoryFuzzTest(const uint8_t * data,size_t size)201 void ResetPolicyFactoryFuzzTest(const uint8_t *data, size_t size)
202 {
203 if ((data == nullptr) || (size == 0)) {
204 return;
205 }
206 g_baseFuzzData = data;
207 g_baseFuzzSize = size;
208 g_baseFuzzPos = 0;
209
210 g_netManagerCenter->ResetPolicyFactory();
211 }
212
ResetPoliciesFuzzTest(const uint8_t * data,size_t size)213 void ResetPoliciesFuzzTest(const uint8_t *data, size_t size)
214 {
215 if ((data == nullptr) || (size == 0)) {
216 return;
217 }
218 g_baseFuzzData = data;
219 g_baseFuzzSize = size;
220 g_baseFuzzPos = 0;
221 g_netManagerCenter->ResetPolicies();
222 }
223
RegisterPolicyServiceFuzzTest(const uint8_t * data,size_t size)224 void RegisterPolicyServiceFuzzTest(const uint8_t *data, size_t size)
225 {
226 if ((data == nullptr) || (size == 0)) {
227 return;
228 }
229 g_baseFuzzData = data;
230 g_baseFuzzSize = size;
231 g_baseFuzzPos = 0;
232 sptr<NetPolicyBaseService> service = new (std::nothrow) NetPolicyServiceCommon();
233 if (service == nullptr) {
234 return;
235 }
236
237 g_netManagerCenter->RegisterPolicyService(service);
238 }
239
ResetEthernetFactoryFuzzTest(const uint8_t * data,size_t size)240 void ResetEthernetFactoryFuzzTest(const uint8_t *data, size_t size)
241 {
242 if ((data == nullptr) || (size == 0)) {
243 return;
244 }
245 g_baseFuzzData = data;
246 g_baseFuzzSize = size;
247 g_baseFuzzPos = 0;
248
249 g_netManagerCenter->ResetEthernetFactory();
250 }
251
RegisterEthernetServiceFuzzTest(const uint8_t * data,size_t size)252 void RegisterEthernetServiceFuzzTest(const uint8_t *data, size_t size)
253 {
254 if ((data == nullptr) || (size == 0)) {
255 return;
256 }
257 g_baseFuzzData = data;
258 g_baseFuzzSize = size;
259 g_baseFuzzPos = 0;
260 sptr<NetEthernetBaseService> service = nullptr;
261 g_netManagerCenter->RegisterEthernetService(service);
262 }
263
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)264 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
265 {
266 if ((data == nullptr) || (size == 0)) {
267 return;
268 }
269 g_baseFuzzData = data;
270 g_baseFuzzSize = size;
271 g_baseFuzzPos = 0;
272 std::string hostName = GetStringFromData(STR_LEN);
273 int32_t netId = GetData<int32_t>();
274 std::vector<INetAddr> addrInfo;
275 g_netManagerCenter->GetAddressesByName(hostName, netId, addrInfo);
276 }
277
RegisterDnsServiceFuzzTest(const uint8_t * data,size_t size)278 void RegisterDnsServiceFuzzTest(const uint8_t *data, size_t size)
279 {
280 if ((data == nullptr) || (size == 0)) {
281 return;
282 }
283 g_baseFuzzData = data;
284 g_baseFuzzSize = size;
285 g_baseFuzzPos = 0;
286 sptr<DnsBaseService> service = nullptr;
287 g_netManagerCenter->RegisterDnsService(service);
288 }
289
RestrictBackgroundChangedFuzzTest(const uint8_t * data,size_t size)290 void RestrictBackgroundChangedFuzzTest(const uint8_t *data, size_t size)
291 {
292 if ((data == nullptr) || (size == 0)) {
293 return;
294 }
295 g_baseFuzzData = data;
296 g_baseFuzzSize = size;
297 g_baseFuzzPos = 0;
298 bool isRestrictBackground = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
299 g_netManagerCenter->RestrictBackgroundChanged(isRestrictBackground);
300 }
301
IsUidNetAccessFuzzTest(const uint8_t * data,size_t size)302 void IsUidNetAccessFuzzTest(const uint8_t *data, size_t size)
303 {
304 if ((data == nullptr) || (size == 0)) {
305 return;
306 }
307
308 g_baseFuzzData = data;
309 g_baseFuzzSize = size;
310 g_baseFuzzPos = 0;
311 uint32_t uid = GetData<uint32_t>();
312 bool metered = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
313 g_netManagerCenter->IsUidNetAccess(uid, metered);
314 }
315
IsUidNetAllowedFuzzTest(const uint8_t * data,size_t size)316 void IsUidNetAllowedFuzzTest(const uint8_t *data, size_t size)
317 {
318 if ((data == nullptr) || (size == 0)) {
319 return;
320 }
321
322 g_baseFuzzData = data;
323 g_baseFuzzSize = size;
324 g_baseFuzzPos = 0;
325 uint32_t uid = GetData<uint32_t>();
326 bool metered = GetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
327 g_netManagerCenter->IsUidNetAllowed(uid, metered);
328 }
329
330 } // namespace NetManagerStandard
331 } // namespace OHOS
332
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)333 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
334 {
335 /* Run your code on data */
336 OHOS::NetManagerStandard::RegisterConnServiceFuzzTest(data, size);
337 OHOS::NetManagerStandard::RegisterStatsServiceFuzzTest(data, size);
338 OHOS::NetManagerStandard::RegisterDnsServiceFuzzTest(data, size);
339 OHOS::NetManagerStandard::RegisterEthernetServiceFuzzTest(data, size);
340 OHOS::NetManagerStandard::RegisterPolicyServiceFuzzTest(data, size);
341 OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
342 OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
343 OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
344 OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
345 OHOS::NetManagerStandard::GetIfaceStatsDetailFuzzTest(data, size);
346 OHOS::NetManagerStandard::ResetStatsFactoryFuzzTest(data, size);
347 OHOS::NetManagerStandard::ResetPolicyFactoryFuzzTest(data, size);
348 OHOS::NetManagerStandard::ResetPoliciesFuzzTest(data, size);
349 OHOS::NetManagerStandard::ResetEthernetFactoryFuzzTest(data, size);
350 OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
351 OHOS::NetManagerStandard::RestrictBackgroundChangedFuzzTest(data, size);
352 OHOS::NetManagerStandard::IsUidNetAccessFuzzTest(data, size);
353 OHOS::NetManagerStandard::IsUidNetAllowedFuzzTest(data, size);
354 OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
355
356 return 0;
357 }