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 <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
NetCommonGetData()42 template <class T> T NetCommonGetData()
43 {
44 T object{};
45 size_t commonSize = sizeof(object);
46 if (g_baseFuzzData == nullptr || commonSize > g_baseFuzzSize - g_baseFuzzPos) {
47 return object;
48 }
49 errno_t ret = memcpy_s(&object, commonSize, g_baseFuzzData + g_baseFuzzPos, commonSize);
50 if (ret != EOK) {
51 return {};
52 }
53 g_baseFuzzPos += commonSize;
54 return object;
55 }
56
NetCommonGetString(int strlen)57 std::string NetCommonGetString(int strlen)
58 {
59 char cstr[strlen];
60 cstr[strlen - 1] = '\0';
61 for (int i = 0; i < strlen - 1; i++) {
62 cstr[i] = NetCommonGetData<char>();
63 }
64 std::string str(cstr);
65 return str;
66 }
67
IsCommonFuzzValidData(const uint8_t * data,size_t size)68 bool IsCommonFuzzValidData(const uint8_t *data, size_t size)
69 {
70 if ((data == nullptr) || (size == 0)) {
71 return false;
72 }
73 g_baseFuzzData = data;
74 g_baseFuzzSize = size;
75 g_baseFuzzPos = 0;
76 return true;
77 }
78
79 static auto g_netManagerCenter = DelayedSingleton<NetManagerCenter>::GetInstance();
80
GetIfaceNamesFuzzTest(const uint8_t * data,size_t size)81 void GetIfaceNamesFuzzTest(const uint8_t *data, size_t size)
82 {
83 if (!IsCommonFuzzValidData(data, size)) {
84 return;
85 }
86
87 uint32_t netType = NetCommonGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
88 std::list<std::string> ifaceNames;
89 g_netManagerCenter->GetIfaceNames(static_cast<NetBearType>(netType), ifaceNames);
90 return;
91 }
92
GetIfaceNameByTypeFuzzTest(const uint8_t * data,size_t size)93 void GetIfaceNameByTypeFuzzTest(const uint8_t *data, size_t size)
94 {
95 if (!IsCommonFuzzValidData(data, size)) {
96 return;
97 }
98
99 uint32_t bearerType = NetCommonGetData<uint32_t>() % CREATE_NET_TYPE_VALUE;
100 std::string ident = NetCommonGetString(STR_LEN);
101 std::string ifaceName = NetCommonGetString(STR_LEN);
102 g_netManagerCenter->GetIfaceNameByType(static_cast<NetBearType>(bearerType), ident, ifaceName);
103 }
104
UnregisterNetSupplierFuzzTest(const uint8_t * data,size_t size)105 void UnregisterNetSupplierFuzzTest(const uint8_t *data, size_t size)
106 {
107 if (!IsCommonFuzzValidData(data, size)) {
108 return;
109 }
110 uint32_t supplierId = NetCommonGetData<uint32_t>();
111 g_netManagerCenter->UnregisterNetSupplier(supplierId);
112 }
113
UpdateNetLinkInfoFuzzTest(const uint8_t * data,size_t size)114 void UpdateNetLinkInfoFuzzTest(const uint8_t *data, size_t size)
115 {
116 if (!IsCommonFuzzValidData(data, size)) {
117 return;
118 }
119 uint32_t supplierId = NetCommonGetData<uint32_t>();
120 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
121 if (netLinkInfo == nullptr) {
122 return;
123 }
124
125 g_netManagerCenter->UpdateNetLinkInfo(supplierId, netLinkInfo);
126 }
127
UpdateNetSupplierInfoFuzzTest(const uint8_t * data,size_t size)128 void UpdateNetSupplierInfoFuzzTest(const uint8_t *data, size_t size)
129 {
130 if (!IsCommonFuzzValidData(data, size)) {
131 return;
132 }
133 uint32_t supplierId = NetCommonGetData<uint32_t>();
134 sptr<NetSupplierInfo> netSupplierInfo = new (std::nothrow) NetSupplierInfo();
135 if (netSupplierInfo == nullptr) {
136 return;
137 }
138 g_netManagerCenter->UpdateNetSupplierInfo(supplierId, netSupplierInfo);
139 }
140
RegisterConnServiceFuzzTest(const uint8_t * data,size_t size)141 __attribute__((no_sanitize("cfi"))) void RegisterConnServiceFuzzTest(const uint8_t *data, size_t size)
142 {
143 if (!IsCommonFuzzValidData(data, size)) {
144 return;
145 }
146 sptr<NetConnServiceIface> serviceIface = new (std::nothrow) NetConnServiceIface();
147 if (serviceIface == nullptr) {
148 return;
149 }
150 g_netManagerCenter->RegisterConnService(serviceIface);
151 }
152
GetIfaceStatsDetailFuzzTest(const uint8_t * data,size_t size)153 void GetIfaceStatsDetailFuzzTest(const uint8_t *data, size_t size)
154 {
155 if (!IsCommonFuzzValidData(data, size)) {
156 return;
157 }
158 std::string iface = NetCommonGetString(STR_LEN);
159 uint32_t start = NetCommonGetData<uint32_t>();
160 uint32_t end = NetCommonGetData<uint32_t>() + start;
161 NetStatsInfo info;
162 g_netManagerCenter->GetIfaceStatsDetail(iface, start, end, info);
163 }
164
ResetStatsFactoryFuzzTest(const uint8_t * data,size_t size)165 void ResetStatsFactoryFuzzTest(const uint8_t *data, size_t size)
166 {
167 if (!IsCommonFuzzValidData(data, size)) {
168 return;
169 }
170
171 g_netManagerCenter->ResetStatsFactory();
172 }
173
RegisterStatsServiceFuzzTest(const uint8_t * data,size_t size)174 void RegisterStatsServiceFuzzTest(const uint8_t *data, size_t size)
175 {
176 if (!IsCommonFuzzValidData(data, size)) {
177 return;
178 }
179 sptr<NetStatsBaseService> service = nullptr;
180
181 g_netManagerCenter->RegisterStatsService(service);
182 }
183
ResetPolicyFactoryFuzzTest(const uint8_t * data,size_t size)184 void ResetPolicyFactoryFuzzTest(const uint8_t *data, size_t size)
185 {
186 if (!IsCommonFuzzValidData(data, size)) {
187 return;
188 }
189
190 g_netManagerCenter->ResetPolicyFactory();
191 }
192
ResetPoliciesFuzzTest(const uint8_t * data,size_t size)193 void ResetPoliciesFuzzTest(const uint8_t *data, size_t size)
194 {
195 if (!IsCommonFuzzValidData(data, size)) {
196 return;
197 }
198 g_netManagerCenter->ResetPolicies();
199 }
200
RegisterPolicyServiceFuzzTest(const uint8_t * data,size_t size)201 void RegisterPolicyServiceFuzzTest(const uint8_t *data, size_t size)
202 {
203 if (!IsCommonFuzzValidData(data, size)) {
204 return;
205 }
206 sptr<NetPolicyBaseService> service = new (std::nothrow) NetPolicyServiceCommon();
207 if (service == nullptr) {
208 return;
209 }
210
211 g_netManagerCenter->RegisterPolicyService(service);
212 }
213
ResetEthernetFactoryFuzzTest(const uint8_t * data,size_t size)214 void ResetEthernetFactoryFuzzTest(const uint8_t *data, size_t size)
215 {
216 if (!IsCommonFuzzValidData(data, size)) {
217 return;
218 }
219
220 g_netManagerCenter->ResetEthernetFactory();
221 }
222
RegisterEthernetServiceFuzzTest(const uint8_t * data,size_t size)223 void RegisterEthernetServiceFuzzTest(const uint8_t *data, size_t size)
224 {
225 if (!IsCommonFuzzValidData(data, size)) {
226 return;
227 }
228 sptr<NetEthernetBaseService> service = nullptr;
229 g_netManagerCenter->RegisterEthernetService(service);
230 }
231
GetAddressesByNameFuzzTest(const uint8_t * data,size_t size)232 void GetAddressesByNameFuzzTest(const uint8_t *data, size_t size)
233 {
234 if (!IsCommonFuzzValidData(data, size)) {
235 return;
236 }
237 std::string hostName = NetCommonGetString(STR_LEN);
238 int32_t netId = NetCommonGetData<int32_t>();
239 std::vector<INetAddr> addrInfo;
240 g_netManagerCenter->GetAddressesByName(hostName, netId, addrInfo);
241 }
242
RegisterDnsServiceFuzzTest(const uint8_t * data,size_t size)243 void RegisterDnsServiceFuzzTest(const uint8_t *data, size_t size)
244 {
245 if (!IsCommonFuzzValidData(data, size)) {
246 return;
247 }
248 sptr<DnsBaseService> service = nullptr;
249 g_netManagerCenter->RegisterDnsService(service);
250 }
251
RestrictBackgroundChangedFuzzTest(const uint8_t * data,size_t size)252 void RestrictBackgroundChangedFuzzTest(const uint8_t *data, size_t size)
253 {
254 if (!IsCommonFuzzValidData(data, size)) {
255 return;
256 }
257 bool isRestrictBackground = NetCommonGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
258 g_netManagerCenter->RestrictBackgroundChanged(isRestrictBackground);
259 }
260
IsUidNetAccessFuzzTest(const uint8_t * data,size_t size)261 void IsUidNetAccessFuzzTest(const uint8_t *data, size_t size)
262 {
263 if (!IsCommonFuzzValidData(data, size)) {
264 return;
265 }
266 uint32_t uid = NetCommonGetData<uint32_t>();
267 bool metered = NetCommonGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
268 g_netManagerCenter->IsUidNetAccess(uid, metered);
269 }
270
IsUidNetAllowedFuzzTest(const uint8_t * data,size_t size)271 void IsUidNetAllowedFuzzTest(const uint8_t *data, size_t size)
272 {
273 if (!IsCommonFuzzValidData(data, size)) {
274 return;
275 }
276 uint32_t uid = NetCommonGetData<uint32_t>();
277 bool metered = NetCommonGetData<uint32_t>() % CONVERT_NUMBER_TO_BOOL == 0;
278 g_netManagerCenter->IsUidNetAllowed(uid, metered);
279 }
280
281 } // namespace NetManagerStandard
282 } // namespace OHOS
283
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)284 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
285 {
286 /* Run your code on data */
287 OHOS::NetManagerStandard::RegisterConnServiceFuzzTest(data, size);
288 OHOS::NetManagerStandard::RegisterStatsServiceFuzzTest(data, size);
289 OHOS::NetManagerStandard::RegisterDnsServiceFuzzTest(data, size);
290 OHOS::NetManagerStandard::RegisterEthernetServiceFuzzTest(data, size);
291 OHOS::NetManagerStandard::RegisterPolicyServiceFuzzTest(data, size);
292 OHOS::NetManagerStandard::GetIfaceNamesFuzzTest(data, size);
293 OHOS::NetManagerStandard::GetIfaceNameByTypeFuzzTest(data, size);
294 OHOS::NetManagerStandard::UpdateNetLinkInfoFuzzTest(data, size);
295 OHOS::NetManagerStandard::UpdateNetSupplierInfoFuzzTest(data, size);
296 OHOS::NetManagerStandard::GetIfaceStatsDetailFuzzTest(data, size);
297 OHOS::NetManagerStandard::ResetStatsFactoryFuzzTest(data, size);
298 OHOS::NetManagerStandard::ResetPolicyFactoryFuzzTest(data, size);
299 OHOS::NetManagerStandard::ResetPoliciesFuzzTest(data, size);
300 OHOS::NetManagerStandard::ResetEthernetFactoryFuzzTest(data, size);
301 OHOS::NetManagerStandard::GetAddressesByNameFuzzTest(data, size);
302 OHOS::NetManagerStandard::RestrictBackgroundChangedFuzzTest(data, size);
303 OHOS::NetManagerStandard::IsUidNetAccessFuzzTest(data, size);
304 OHOS::NetManagerStandard::IsUidNetAllowedFuzzTest(data, size);
305 OHOS::NetManagerStandard::UnregisterNetSupplierFuzzTest(data, size);
306
307 return 0;
308 }