1 /*
2  * Copyright (c) 2023 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 "wifidevicestub_fuzzer.h"
17 #include "wifi_fuzz_common_func.h"
18 
19 #include <cstddef>
20 #include <cstdint>
21 #include <unistd.h>
22 #include "wifi_device_stub.h"
23 #include "wifi_device_mgr_stub.h"
24 #include "message_parcel.h"
25 #include "securec.h"
26 #include "define.h"
27 #include "wifi_manager_service_ipc_interface_code.h"
28 #include "wifi_device_service_impl.h"
29 #include "wifi_device_mgr_service_impl.h"
30 #include "wifi_log.h"
31 #include <mutex>
32 #include "wifi_config_center.h"
33 #include "wifi_settings.h"
34 #include "wifi_common_def.h"
35 #include "wifi_manager.h"
36 #include "wifi_net_agent.h"
37 
38 namespace OHOS {
39 namespace Wifi {
40 constexpr size_t U32_AT_SIZE_ZERO = 4;
41 constexpr int TWO = 2;
42 constexpr int FIVE = 5;
43 constexpr int NINE = 9;
44 static bool g_isInsted = false;
45 static std::mutex g_instanceLock;
46 const std::u16string FORMMGR_INTERFACE_TOKEN = u"ohos.wifi.IWifiDeviceService";
47 const std::u16string FORMMGR_INTERFACE_TOKEN_DEVICE_EX = u"ohos.wifi.IWifiDeviceMgr";
48 std::shared_ptr<WifiDeviceServiceImpl> pWifiDeviceServiceImpl = std::make_shared<WifiDeviceServiceImpl>();
49 std::shared_ptr<WifiDeviceStub> pWifiDeviceStub = std::make_shared<WifiDeviceServiceImpl>();
50 sptr<WifiDeviceMgrStub> pWifiDeviceMgrStub = WifiDeviceMgrServiceImpl::GetInstance();
51 
52 class IWifiDeviceCallBackMock : public IWifiDeviceCallBack {
53 public:
IWifiDeviceCallBackMock()54     IWifiDeviceCallBackMock()
55     {
56         LOGE("IWifiDeviceCallBackMock");
57     }
58 
~IWifiDeviceCallBackMock()59     ~IWifiDeviceCallBackMock()
60     {
61         LOGE("~IWifiDeviceCallBackMock");
62     }
63 
64 public:
65     void OnWifiStateChanged(int state) override
66     {
67         LOGE("OnWifiStateChanged test");
68     }
69 
70     void OnWifiConnectionChanged(int state, const WifiLinkedInfo &info) override
71     {
72         LOGE("OnWifiConnectionChanged test");
73     }
74 
75     void OnWifiRssiChanged(int rssi) override
76     {
77         LOGE("OnWifiRssiChanged test");
78     }
79 
80     void OnWifiWpsStateChanged(int state, const std::string &pinCode) override
81     {
82         LOGE("OnWifiWpsStateChanged test");
83     }
84 
85     void OnStreamChanged(int direction) override
86     {
87         LOGE("OnStreamChanged test");
88     }
89 
90     void OnDeviceConfigChanged(ConfigChange value) override
91     {
92         LOGE("OnDeviceConfigChanged test");
93     }
94 
95     OHOS::sptr<OHOS::IRemoteObject> AsObject() override
96     {
97         return nullptr;
98     }
99 };
100 
Init()101 bool Init()
102 {
103     if (!g_isInsted) {
104         if (WifiConfigCenter::GetInstance().GetWifiMidState(0) != WifiOprMidState::RUNNING) {
105             WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::RUNNING, 0);
106         }
107         g_isInsted = true;
108     }
109     return true;
110 }
111 
OnRemoteRequest(uint32_t code, MessageParcel &data)112 bool OnRemoteRequest(uint32_t code, MessageParcel &data)
113 {
114     std::unique_lock<std::mutex> autoLock(g_instanceLock);
115     if (!g_isInsted) {
116         if (!Init()) {
117             LOGE("OnRemoteRequest Init failed!");
118             return false;
119         }
120     }
121     MessageParcel reply;
122     MessageOption option;
123     pWifiDeviceStub->OnRemoteRequest(code, data, reply, option);
124     return true;
125 }
126 
OnInitWifiProtectFuzzTest(const uint8_t* data, size_t size)127 void OnInitWifiProtectFuzzTest(const uint8_t* data, size_t size)
128 {
129     MessageParcel datas;
130     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
131         LOGE("WriteInterfaceToken failed!");
132         return;
133     }
134     datas.WriteInt32(0);
135     datas.WriteBuffer(data, size);
136     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_INIT_WIFI_PROTECT), datas);
137 }
138 
OnGetWifiProtectRefFuzzTest(const uint8_t* data, size_t size)139 void OnGetWifiProtectRefFuzzTest(const uint8_t* data, size_t size)
140 {
141     MessageParcel datas;
142     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
143         LOGE("WriteInterfaceToken failed!");
144         return;
145     }
146     datas.WriteInt32(0);
147     datas.WriteBuffer(data, size);
148     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_PROTECT), datas);
149 }
150 
OnPutWifiProtectRefFuzzTest(const uint8_t* data, size_t size)151 void OnPutWifiProtectRefFuzzTest(const uint8_t* data, size_t size)
152 {
153     MessageParcel datas;
154     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
155         LOGE("WriteInterfaceToken failed!");
156         return;
157     }
158     datas.WriteInt32(0);
159     datas.WriteBuffer(data, size);
160     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_PUT_WIFI_PROTECT), datas);
161 }
162 
OnIsHeldWifiProtectRefFuzzTest(const uint8_t* data, size_t size)163 void OnIsHeldWifiProtectRefFuzzTest(const uint8_t* data, size_t size)
164 {
165     MessageParcel datas;
166     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
167         LOGE("WriteInterfaceToken failed!");
168         return;
169     }
170     datas.WriteInt32(0);
171     datas.WriteBuffer(data, size);
172     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_HELD_WIFI_PROTECT), datas);
173 }
174 
OnAddDeviceConfigFuzzTest(const uint8_t* data, size_t size)175 void OnAddDeviceConfigFuzzTest(const uint8_t* data, size_t size)
176 {
177     MessageParcel datas;
178     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
179         LOGE("WriteInterfaceToken failed!");
180         return;
181     }
182     datas.WriteInt32(0);
183     datas.WriteBuffer(data, size);
184     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ADD_DEVICE_CONFIG), datas);
185 }
186 
OnUpdateDeviceConfigFuzzTest(const uint8_t* data, size_t size)187 void OnUpdateDeviceConfigFuzzTest(const uint8_t* data, size_t size)
188 {
189     MessageParcel datas;
190     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
191         LOGE("WriteInterfaceToken failed!");
192         return;
193     }
194     datas.WriteInt32(0);
195     datas.WriteBuffer(data, size);
196     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_UPDATE_DEVICE_CONFIG), datas);
197 }
198 
OnRemoveDeviceFuzzTest(const uint8_t* data, size_t size)199 void OnRemoveDeviceFuzzTest(const uint8_t* data, size_t size)
200 {
201     MessageParcel datas;
202     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
203         LOGE("WriteInterfaceToken failed!");
204         return;
205     }
206     datas.WriteInt32(0);
207     datas.WriteBuffer(data, size);
208     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_DEVICE_CONFIG), datas);
209 }
210 
OnRemoveAllDeviceFuzzTest(const uint8_t* data, size_t size)211 void OnRemoveAllDeviceFuzzTest(const uint8_t* data, size_t size)
212 {
213     MessageParcel datas;
214     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
215         LOGE("WriteInterfaceToken failed!");
216         return;
217     }
218     datas.WriteInt32(0);
219     datas.WriteBuffer(data, size);
220     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_ALL_DEVICE_CONFIG), datas);
221 }
222 
OnGetDeviceConfigsFuzzTest(const uint8_t* data, size_t size)223 void OnGetDeviceConfigsFuzzTest(const uint8_t* data, size_t size)
224 {
225     MessageParcel datas;
226     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
227         LOGE("WriteInterfaceToken failed!");
228         return;
229     }
230     datas.WriteInt32(0);
231     datas.WriteBuffer(data, size);
232     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIGS), datas);
233 }
234 
OnEnableDeviceConfigFuzzTest(const uint8_t* data, size_t size)235 void OnEnableDeviceConfigFuzzTest(const uint8_t* data, size_t size)
236 {
237     MessageParcel datas;
238     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
239         LOGE("WriteInterfaceToken failed!");
240         return;
241     }
242     datas.WriteInt32(0);
243     datas.WriteBuffer(data, size);
244     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_DEVICE), datas);
245 }
246 
OnDisableDeviceConfigFuzzTest(const uint8_t* data, size_t size)247 void OnDisableDeviceConfigFuzzTest(const uint8_t* data, size_t size)
248 {
249     MessageParcel datas;
250     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
251         LOGE("WriteInterfaceToken failed!");
252         return;
253     }
254     datas.WriteInt32(0);
255     datas.WriteBuffer(data, size);
256     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_DEVICE), datas);
257 }
258 
OnConnectToFuzzTest(const uint8_t* data, size_t size)259 void OnConnectToFuzzTest(const uint8_t* data, size_t size)
260 {
261     MessageParcel datas;
262     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
263         LOGE("WriteInterfaceToken failed!");
264         return;
265     }
266     datas.WriteInt32(0);
267     datas.WriteBuffer(data, size);
268     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CONNECT_TO), datas);
269 }
270 
OnConnect2ToFuzzTest(const uint8_t* data, size_t size)271 void OnConnect2ToFuzzTest(const uint8_t* data, size_t size)
272 {
273     MessageParcel datas;
274     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
275         LOGE("WriteInterfaceToken failed!");
276         return;
277     }
278     datas.WriteInt32(0);
279     datas.WriteBuffer(data, size);
280     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CONNECT2_TO), datas);
281 }
282 
OnReConnectFuzzTest(const uint8_t* data, size_t size)283 void OnReConnectFuzzTest(const uint8_t* data, size_t size)
284 {
285     MessageParcel datas;
286     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
287         LOGE("WriteInterfaceToken failed!");
288         return;
289     }
290     datas.WriteInt32(0);
291     datas.WriteBuffer(data, size);
292     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_RECONNECT), datas);
293 }
294 
OnReAssociateFuzzTest(const uint8_t* data, size_t size)295 void OnReAssociateFuzzTest(const uint8_t* data, size_t size)
296 {
297     MessageParcel datas;
298     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
299         LOGE("WriteInterfaceToken failed!");
300         return;
301     }
302     datas.WriteInt32(0);
303     datas.WriteBuffer(data, size);
304     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REASSOCIATE), datas);
305 }
306 
OnDisconnectFuzzTest(const uint8_t* data, size_t size)307 void OnDisconnectFuzzTest(const uint8_t* data, size_t size)
308 {
309     MessageParcel datas;
310     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
311         LOGE("WriteInterfaceToken failed!");
312         return;
313     }
314     datas.WriteInt32(0);
315     datas.WriteBuffer(data, size);
316     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISCONNECT), datas);
317 }
318 
OnStartWpsFuzzTest(const uint8_t* data, size_t size)319 void OnStartWpsFuzzTest(const uint8_t* data, size_t size)
320 {
321     MessageParcel datas;
322     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
323         LOGE("WriteInterfaceToken failed!");
324         return;
325     }
326     datas.WriteInt32(0);
327     datas.WriteBuffer(data, size);
328     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_WPS), datas);
329 }
330 
OnCancelWpsFuzzTest(const uint8_t* data, size_t size)331 void OnCancelWpsFuzzTest(const uint8_t* data, size_t size)
332 {
333     MessageParcel datas;
334     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
335         LOGE("WriteInterfaceToken failed!");
336         return;
337     }
338     datas.WriteInt32(0);
339     datas.WriteBuffer(data, size);
340     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_CANCEL_WPS), datas);
341 }
342 
OnIsWifiActiveFuzzTest(const uint8_t* data, size_t size)343 void OnIsWifiActiveFuzzTest(const uint8_t* data, size_t size)
344 {
345     MessageParcel datas;
346     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
347         LOGE("WriteInterfaceToken failed!");
348         return;
349     }
350     datas.WriteInt32(0);
351     datas.WriteBuffer(data, size);
352     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_ACTIVE), datas);
353 }
354 
OnGetWifiStateFuzzTest(const uint8_t* data, size_t size)355 void OnGetWifiStateFuzzTest(const uint8_t* data, size_t size)
356 {
357     MessageParcel datas;
358     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
359         LOGE("WriteInterfaceToken failed!");
360         return;
361     }
362     datas.WriteInt32(0);
363     datas.WriteBuffer(data, size);
364     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_STATE), datas);
365 }
366 
OnGetLinkedInfoFuzzTest(const uint8_t* data, size_t size)367 void OnGetLinkedInfoFuzzTest(const uint8_t* data, size_t size)
368 {
369     MessageParcel datas;
370     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
371         LOGE("WriteInterfaceToken failed!");
372         return;
373     }
374     datas.WriteInt32(0);
375     datas.WriteBuffer(data, size);
376     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_LINKED_INFO), datas);
377 }
378 
OnIsMeteredHotspotFuzzTest(const uint8_t* data, size_t size)379 void OnIsMeteredHotspotFuzzTest(const uint8_t* data, size_t size)
380 {
381     MessageParcel datas;
382     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
383         LOGE("WriteInterfaceToken failed!");
384         return;
385     }
386     datas.WriteInt32(0);
387     datas.WriteBuffer(data, size);
388     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_METERED_HOTSPOT), datas);
389 }
390 
OnGetIpInfoFuzzTest(const uint8_t* data, size_t size)391 void OnGetIpInfoFuzzTest(const uint8_t* data, size_t size)
392 {
393     MessageParcel datas;
394     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
395         LOGE("WriteInterfaceToken failed!");
396         return;
397     }
398     datas.WriteInt32(0);
399     datas.WriteBuffer(data, size);
400     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DHCP_INFO), datas);
401 }
402 
OnSetCountryCodeFuzzTest(const uint8_t* data, size_t size)403 void OnSetCountryCodeFuzzTest(const uint8_t* data, size_t size)
404 {
405     MessageParcel datas;
406     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
407         LOGE("WriteInterfaceToken failed!");
408         return;
409     }
410     datas.WriteInt32(0);
411     datas.WriteBuffer(data, size);
412     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_COUNTRY_CODE), datas);
413 }
414 
OnGetCountryCodeFuzzTest(const uint8_t* data, size_t size)415 void OnGetCountryCodeFuzzTest(const uint8_t* data, size_t size)
416 {
417     MessageParcel datas;
418     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
419         LOGE("WriteInterfaceToken failed!");
420         return;
421     }
422     datas.WriteInt32(0);
423     datas.WriteBuffer(data, size);
424     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_COUNTRY_CODE), datas);
425 }
426 
OnRegisterCallBackFuzzTest(const uint8_t* data, size_t size)427 void OnRegisterCallBackFuzzTest(const uint8_t* data, size_t size)
428 {
429     MessageParcel datas;
430     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
431         LOGE("WriteInterfaceToken failed!");
432         return;
433     }
434     datas.WriteInt32(0);
435     datas.WriteBuffer(data, size);
436     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REGISTER_CALLBACK_CLIENT), datas);
437 }
438 
OnGetSignalLevelFuzzTest(const uint8_t* data, size_t size)439 void OnGetSignalLevelFuzzTest(const uint8_t* data, size_t size)
440 {
441     MessageParcel datas;
442     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
443         LOGE("WriteInterfaceToken failed!");
444         return;
445     }
446     datas.WriteInt32(0);
447     datas.WriteBuffer(data, size);
448     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_SIGNAL_LEVEL), datas);
449 }
450 
OnGetIpV6InfoFuzzTest(const uint8_t* data, size_t size)451 void OnGetIpV6InfoFuzzTest(const uint8_t* data, size_t size)
452 {
453     MessageParcel datas;
454     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
455         LOGE("WriteInterfaceToken failed!");
456         return;
457     }
458     datas.WriteInt32(0);
459     datas.WriteBuffer(data, size);
460     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DHCP_IPV6INFO), datas);
461 }
462 
OnGetDeviceMacAddFuzzTest(const uint8_t* data, size_t size)463 void OnGetDeviceMacAddFuzzTest(const uint8_t* data, size_t size)
464 {
465     MessageParcel datas;
466     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
467         LOGE("WriteInterfaceToken failed!");
468         return;
469     }
470     datas.WriteInt32(0);
471     datas.WriteBuffer(data, size);
472     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DERVICE_MAC_ADD), datas);
473 }
474 
OnIsWifiConnectedFuzzTest(const uint8_t* data, size_t size)475 void OnIsWifiConnectedFuzzTest(const uint8_t* data, size_t size)
476 {
477     MessageParcel datas;
478     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
479         LOGE("WriteInterfaceToken failed!");
480         return;
481     }
482     datas.WriteInt32(0);
483     datas.WriteBuffer(data, size);
484     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_WIFI_CONNECTED), datas);
485 }
486 
OnSetLowLatencyModeFuzzTest(const uint8_t* data, size_t size)487 void OnSetLowLatencyModeFuzzTest(const uint8_t* data, size_t size)
488 {
489     MessageParcel datas;
490     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
491         LOGE("WriteInterfaceToken failed!");
492         return;
493     }
494     datas.WriteInt32(0);
495     datas.WriteBuffer(data, size);
496     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_LOW_LATENCY_MODE), datas);
497 }
498 
OnRemoveCandidateConfigFuzzTest(const uint8_t* data, size_t size)499 void OnRemoveCandidateConfigFuzzTest(const uint8_t* data, size_t size)
500 {
501     MessageParcel datas;
502     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
503         LOGE("WriteInterfaceToken failed!");
504         return;
505     }
506     datas.WriteInt32(0);
507     datas.WriteBuffer(data, size);
508     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_REMOVE_CANDIDATE_CONFIG), datas);
509 }
510 
OnIsBandTypeSupportedFuzzTest(const uint8_t* data, size_t size)511 void OnIsBandTypeSupportedFuzzTest(const uint8_t* data, size_t size)
512 {
513     MessageParcel datas;
514     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
515         LOGE("WriteInterfaceToken failed!");
516         return;
517     }
518     datas.WriteInt32(0);
519     datas.WriteBuffer(data, size);
520     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_BANDTYPE_SUPPORTED), datas);
521 }
522 
OnGet5GHzChannelListFuzzTest(const uint8_t* data, size_t size)523 void OnGet5GHzChannelListFuzzTest(const uint8_t* data, size_t size)
524 {
525     MessageParcel datas;
526     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
527         LOGE("WriteInterfaceToken failed!");
528         return;
529     }
530     datas.WriteInt32(0);
531     datas.WriteBuffer(data, size);
532     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_5G_CHANNELLIST), datas);
533 }
534 
OnGetDisconnectedReasonFuzzTest(const uint8_t* data, size_t size)535 void OnGetDisconnectedReasonFuzzTest(const uint8_t* data, size_t size)
536 {
537     MessageParcel datas;
538     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
539         LOGE("WriteInterfaceToken failed!");
540         return;
541     }
542     datas.WriteInt32(0);
543     datas.WriteBuffer(data, size);
544     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DISCONNECTED_REASON), datas);
545 }
546 
OnSetFrozenAppFuzzTest(const uint8_t* data, size_t size)547 void OnSetFrozenAppFuzzTest(const uint8_t* data, size_t size)
548 {
549     MessageParcel datas;
550     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
551         LOGE("WriteInterfaceToken failed!");
552         return;
553     }
554     datas.WriteInt32(0);
555     datas.WriteBuffer(data, size);
556     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_FROZEN_APP), datas);
557 }
558 
OnResetAllFrozenAppFuzzTest(const uint8_t* data, size_t size)559 void OnResetAllFrozenAppFuzzTest(const uint8_t* data, size_t size)
560 {
561     MessageParcel datas;
562     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
563         LOGE("WriteInterfaceToken failed!");
564         return;
565     }
566     datas.WriteInt32(0);
567     datas.WriteBuffer(data, size);
568     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_RESET_ALL_FROZEN_APP), datas);
569 }
570 
OnDisableAutoJoinFuzzTest(const uint8_t* data, size_t size)571 void OnDisableAutoJoinFuzzTest(const uint8_t* data, size_t size)
572 {
573     MessageParcel datas;
574     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
575         LOGE("WriteInterfaceToken failed!");
576         return;
577     }
578     datas.WriteInt32(0);
579     datas.WriteBuffer(data, size);
580     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_AUTO_JOIN), datas);
581 }
582 
OnEnableAutoJoinFuzzTest(const uint8_t* data, size_t size)583 void OnEnableAutoJoinFuzzTest(const uint8_t* data, size_t size)
584 {
585     MessageParcel datas;
586     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
587         LOGE("WriteInterfaceToken failed!");
588         return;
589     }
590     datas.WriteInt32(0);
591     datas.WriteBuffer(data, size);
592     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_AUTO_JOIN), datas);
593 }
594 
OnStartPortalCertificationFuzzTest(const uint8_t* data, size_t size)595 void OnStartPortalCertificationFuzzTest(const uint8_t* data, size_t size)
596 {
597     MessageParcel datas;
598     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
599         LOGE("WriteInterfaceToken failed!");
600         return;
601     }
602     datas.WriteInt32(0);
603     datas.WriteBuffer(data, size);
604     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_START_PORTAL_CERTIF), datas);
605 }
606 
OnGetChangeDeviceConfigFuzzTest(const uint8_t* data, size_t size)607 void OnGetChangeDeviceConfigFuzzTest(const uint8_t* data, size_t size)
608 {
609     MessageParcel datas;
610     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
611         LOGE("WriteInterfaceToken failed!");
612         return;
613     }
614     datas.WriteInt32(0);
615     datas.WriteBuffer(data, size);
616     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_DEVICE_CONFIG_CHANGE), datas);
617 }
618 
OnLimitSpeedFuzzTest(const uint8_t* data, size_t size)619 void OnLimitSpeedFuzzTest(const uint8_t* data, size_t size)
620 {
621     MessageParcel datas;
622     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
623         LOGE("WriteInterfaceToken failed!");
624         return;
625     }
626     datas.WriteInt32(0);
627     datas.WriteBuffer(data, size);
628     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_LIMIT_SPEED), datas);
629 }
630 
OnEnableHiLinkHandshakeFuzzTest(const uint8_t* data, size_t size)631 void OnEnableHiLinkHandshakeFuzzTest(const uint8_t* data, size_t size)
632 {
633     MessageParcel datas;
634     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
635         LOGE("WriteInterfaceToken failed!");
636         return;
637     }
638     datas.WriteInt32(0);
639     datas.WriteBuffer(data, size);
640     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_HILINK_CONNECT), datas);
641 }
642 
OnSetSatelliteStateFuzzTest(const uint8_t* data, size_t size)643 void OnSetSatelliteStateFuzzTest(const uint8_t* data, size_t size)
644 {
645     MessageParcel datas;
646     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
647         LOGE("WriteInterfaceToken failed!");
648         return;
649     }
650     datas.WriteInt32(0);
651     datas.WriteBuffer(data, size);
652     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_SATELLITE_STATE), datas);
653 }
654 
OnFactoryResetFuzzTest(const uint8_t* data, size_t size)655 void OnFactoryResetFuzzTest(const uint8_t* data, size_t size)
656 {
657     MessageParcel datas;
658     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
659         LOGE("WriteInterfaceToken failed!");
660         return;
661     }
662     datas.WriteInt32(0);
663     datas.WriteBuffer(data, size);
664     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_IS_SET_FACTORY_RESET), datas);
665 }
666 
OnEnableWifiFuzzTest(const uint8_t* data, size_t size)667 void OnEnableWifiFuzzTest(const uint8_t* data, size_t size)
668 {
669     MessageParcel datas;
670     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
671         LOGE("WriteInterfaceToken failed!");
672         return;
673     }
674     datas.WriteInt32(0);
675     datas.WriteBuffer(data, size);
676     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_WIFI), datas);
677 }
678 
OnDisableWifiFuzzTest(const uint8_t* data, size_t size)679 void OnDisableWifiFuzzTest(const uint8_t* data, size_t size)
680 {
681     MessageParcel datas;
682     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
683         LOGE("WriteInterfaceToken failed!");
684         return;
685     }
686     datas.WriteInt32(0);
687     datas.WriteBuffer(data, size);
688     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_DISABLE_WIFI), datas);
689 }
690 
OnGetSupportedFeaturesFuzzTest(const uint8_t* data, size_t size)691 void OnGetSupportedFeaturesFuzzTest(const uint8_t* data, size_t size)
692 {
693     MessageParcel datas;
694     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
695         LOGE("WriteInterfaceToken failed!");
696         return;
697     }
698     datas.WriteInt32(0);
699     datas.WriteBuffer(data, size);
700     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_SUPPORTED_FEATURES), datas);
701 }
702 
OnEnableSemiWifiFuzzTest(const uint8_t* data, size_t size)703 void OnEnableSemiWifiFuzzTest(const uint8_t* data, size_t size)
704 {
705     MessageParcel datas;
706     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
707         LOGE("WriteInterfaceToken failed!");
708         return;
709     }
710     datas.WriteInt32(0);
711     datas.WriteBuffer(data, size);
712     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_ENABLE_SEMI_WIFI), datas);
713 }
714 
OnGetWifiDetailStateFuzzTest(const uint8_t* data, size_t size)715 void OnGetWifiDetailStateFuzzTest(const uint8_t* data, size_t size)
716 {
717     MessageParcel datas;
718     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
719         LOGE("WriteInterfaceToken failed!");
720         return;
721     }
722     datas.WriteInt32(0);
723     datas.WriteBuffer(data, size);
724     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_GET_WIFI_DETAIL_STATE), datas);
725 }
726 
OnSetTxPowerFuzzTest(const uint8_t* data, size_t size)727 void OnSetTxPowerFuzzTest(const uint8_t* data, size_t size)
728 {
729     MessageParcel datas;
730     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
731         LOGE("WriteInterfaceToken failed!");
732         return;
733     }
734     datas.WriteInt32(0);
735     datas.WriteBuffer(data, size);
736     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_TX_POWER), datas);
737 }
738 
OnSetLowTxPowerTest(const uint8_t* data, size_t size)739 void OnSetLowTxPowerTest(const uint8_t* data, size_t size)
740 {
741     MessageParcel datas;
742     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
743         LOGE("WriteInterfaceToken failed!");
744         return;
745     }
746     datas.WriteInt32(0);
747     datas.WriteBuffer(data, size);
748     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_LOW_TX_POWER), datas);
749 }
750 
OnSetDpiMarkRuleTest(const uint8_t* data, size_t size)751 void OnSetDpiMarkRuleTest(const uint8_t* data, size_t size)
752 {
753     MessageParcel datas;
754     if (!datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN)) {
755         LOGE("WriteInterfaceToken failed!");
756         return;
757     }
758     datas.WriteInt32(0);
759     datas.WriteBuffer(data, size);
760     OnRemoteRequest(static_cast<uint32_t>(DevInterfaceCode::WIFI_SVR_CMD_SET_DPI_MARK_RULE), datas);
761 }
762 
DoSomethingDeviceMgrStubTest(const uint8_t* data, size_t size)763 void DoSomethingDeviceMgrStubTest(const uint8_t* data, size_t size)
764 {
765     std::string networkName = "backup";
766     std::string name = "restore";
767     uint32_t code = static_cast<uint32_t>(DevInterfaceCode::WIFI_MGR_GET_DEVICE_SERVICE);
768     MessageParcel datas;
769     datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN_DEVICE_EX);
770     datas.WriteInt32(0);
771     datas.WriteBuffer(data, size);
772     datas.RewindRead(0);
773     MessageParcel reply;
774     MessageOption option;
775     WifiDeviceMgrServiceImpl mWifiDeviceMgrServiceImpl;
776     pWifiDeviceMgrStub->OnRemoteRequest(code, datas, reply, option);
777     mWifiDeviceMgrServiceImpl.OnExtension(networkName, datas, reply);
778     mWifiDeviceMgrServiceImpl.OnExtension(name, datas, reply);
779 }
780 
WifiFuzzTest()781 bool WifiFuzzTest()
782 {
783     return true;
784 }
785 
WifiDeviceServiceImplTest(const uint8_t* data, size_t size)786 void WifiDeviceServiceImplTest(const uint8_t* data, size_t size)
787 {
788     int index = 0;
789     int networkId = static_cast<int>(data[index++]);
790     int uid = static_cast<int>(data[index++]);
791     std::string networkName = std::string(reinterpret_cast<const char*>(data), size);
792     FilterTag filterTag = static_cast<FilterTag>(static_cast<int>(data[0]) % FIVE);
793     bool attemptEnable = (static_cast<int>(data[0]) % TWO) ? true : false;
794     WifiDeviceServiceImpl mWifiDeviceServiceImpl;
795     MessageParcel datas;
796     WifiDeviceConfig config;
797     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
798     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
799     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
800     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
801     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
802     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
803     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
804     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
805     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
806 
807     mWifiDeviceServiceImpl.DeregisterAutoJoinCondition(networkName);
808     mWifiDeviceServiceImpl.DeregisterFilterBuilder(filterTag, networkName);
809     mWifiDeviceServiceImpl.RegisterAutoJoinCondition(networkName, WifiFuzzTest);
810     mWifiDeviceServiceImpl.HilinkGetMacAddress(config, config.ssid);
811     mWifiDeviceServiceImpl.SaBasicDump(config.ssid);
812     mWifiDeviceServiceImpl.IsScanServiceRunning();
813     mWifiDeviceServiceImpl.StartRoamToNetwork(networkId, networkName, attemptEnable);
814     mWifiDeviceServiceImpl.IsWifiBrokerProcess(uid);
815     mWifiDeviceServiceImpl.CheckConfigPwd(config);
816     mWifiDeviceServiceImpl.CheckConfigEap(config);
817     pWifiDeviceStub->WriteEapConfig(datas, config.wifiEapConfig);
818     pWifiDeviceStub->WriteWifiDeviceConfig(datas, config);
819 }
820 
CheckConfigEapTest(const uint8_t* data, size_t size)821 void CheckConfigEapTest(const uint8_t* data, size_t size)
822 {
823     WifiDeviceConfig config;
824     int index = 0;
825     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
826     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
827     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
828     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
829     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
830     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
831     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
832     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
833     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
834     std::string keyMgmtWapiPsk = "WPA-PSK";
835     config.keyMgmt = keyMgmtWapiPsk;
836     pWifiDeviceServiceImpl->CheckConfigEap(config);
837     config.keyMgmt.clear();
838     std::string eapMethodPeap = "PEAP";
839     config.wifiEapConfig.eap = EAP_METHOD_PEAP;
840     pWifiDeviceServiceImpl->CheckConfigEap(config);
841     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
842     pWifiDeviceServiceImpl->CheckConfigEap(config);
843 }
844 
CheckConfigWapiTest(const uint8_t* data, size_t size)845 void CheckConfigWapiTest(const uint8_t* data, size_t size)
846 {
847     WifiDeviceConfig config;
848     int index = 0;
849     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
850     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
851     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
852     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
853     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
854     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
855     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
856     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
857     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
858     std::string keyMgmtwapiPsk = "WAPI-PSK";
859     config.keyMgmt = keyMgmtwapiPsk;
860     pWifiDeviceServiceImpl->CheckConfigWapi(config);
861     config.keyMgmt.clear();
862     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
863     pWifiDeviceServiceImpl->CheckConfigWapi(config);
864 }
865 
CheckConfigPwdTest(const uint8_t* data, size_t size)866 void CheckConfigPwdTest(const uint8_t* data, size_t size)
867 {
868     WifiDeviceConfig config;
869     int index = 0;
870     std::string ssidLength = "name";
871     config.ssid = ssidLength;
872     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
873     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
874     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
875     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
876     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
877     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
878     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
879     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
880     pWifiDeviceServiceImpl->CheckConfigPwd(config);
881 }
882 
InitWifiBrokerProcessInfoTest(const uint8_t* data, size_t size)883 void InitWifiBrokerProcessInfoTest(const uint8_t* data, size_t size)
884 {
885     WifiDeviceConfig config;
886     int index = 0;
887     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
888     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
889     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
890     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
891     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
892     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
893     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
894     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
895     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
896     std::string ancoServiceBroker = "anco_service_broker";
897     config.callProcessName = ancoServiceBroker;
898     pWifiDeviceServiceImpl->InitWifiBrokerProcessInfo(config);
899 }
900 
SetWifiConnectedModeTest(const uint8_t* data, size_t size)901 void SetWifiConnectedModeTest(const uint8_t* data, size_t size)
902 {
903     pWifiDeviceServiceImpl->SetWifiConnectedMode();
904 }
905 
RemoveCandidateConfigFuzzTest(const uint8_t* data, size_t size)906 void RemoveCandidateConfigFuzzTest(const uint8_t* data, size_t size)
907 {
908     WifiDeviceConfig config;
909     int index = 0;
910     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
911     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
912     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
913     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
914     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
915     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
916     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
917     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
918     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
919     config.callProcessName = std::string(reinterpret_cast<const char*>(data), size);
920     pWifiDeviceServiceImpl->RemoveCandidateConfig(config);
921 }
922 
RemoveCandidateConfigTest(const uint8_t* data, size_t size)923 void RemoveCandidateConfigTest(const uint8_t* data, size_t size)
924 {
925     int index = 0;
926     int networkId = static_cast<int>(data[index++]);
927     pWifiDeviceServiceImpl->RemoveCandidateConfig(networkId);
928 }
929 
AddDeviceConfigTest(const uint8_t* data, size_t size)930 void AddDeviceConfigTest(const uint8_t* data, size_t size)
931 {
932     WifiDeviceConfig config;
933     int result = 0;
934     int index = 0;
935     bool isCandidate = (static_cast<int>(data[0]) % TWO) ? true : false;
936     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
937     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
938     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
939     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
940     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
941     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
942     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
943     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
944     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
945     config.callProcessName = std::string(reinterpret_cast<const char*>(data), size);
946     pWifiDeviceServiceImpl->AddDeviceConfig(config, result, isCandidate);
947 }
948 
ConnectToNetworkTest(const uint8_t* data, size_t size)949 void ConnectToNetworkTest(const uint8_t* data, size_t size)
950 {
951     int index = 0;
952     int networkId = static_cast<int>(data[index++]);
953     bool isCandidate = (static_cast<int>(data[0]) % TWO) ? true : false;
954     pWifiDeviceServiceImpl->ConnectToNetwork(networkId, isCandidate);
955 }
956 
ConnectToDeviceTest(const uint8_t* data, size_t size)957 void ConnectToDeviceTest(const uint8_t* data, size_t size)
958 {
959     WifiDeviceConfig config;
960     int index = 0;
961     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
962     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
963     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
964     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
965     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
966     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
967     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
968     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
969     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
970     pWifiDeviceServiceImpl->ConnectToDevice(config);
971 }
972 
SaBasicDumpTest(const uint8_t* data, size_t size)973 void SaBasicDumpTest(const uint8_t* data, size_t size)
974 {
975     WifiLinkedInfo info;
976     info.connState = static_cast<ConnState>(static_cast<int>(data[0]) % NINE);
977     WifiConfigCenter::GetInstance().SaveLinkedInfo(info, 0);
978     std::string result;
979     pWifiDeviceServiceImpl->SaBasicDump(result);
980 }
981 
IsRemoteDiedTest(const uint8_t* data, size_t size)982 void IsRemoteDiedTest(const uint8_t* data, size_t size)
983 {
984     pWifiDeviceServiceImpl->IsRemoteDied();
985 }
986 
IsBandTypeSupportedTest(const uint8_t* data, size_t size)987 void IsBandTypeSupportedTest(const uint8_t* data, size_t size)
988 {
989     int bandType = static_cast<int>(data[0]);
990     bool supported = (static_cast<int>(data[0]) % TWO) ? true : false;
991     pWifiDeviceServiceImpl->IsBandTypeSupported(bandType, supported);
992 }
993 
RegisterCallBackTest(const uint8_t* data, size_t size)994 void RegisterCallBackTest(const uint8_t* data, size_t size)
995 {
996     std::vector<std::string> event;
997     sptr<IWifiDeviceCallBack> callBack = new (std::nothrow) IWifiDeviceCallBackMock();
998     pWifiDeviceServiceImpl->RegisterCallBack(callBack, event);
999     pWifiDeviceServiceImpl->RegisterCallBack(nullptr, event);
1000 }
1001 
CheckCanEnableWifiTest(const uint8_t* data, size_t size)1002 void CheckCanEnableWifiTest(const uint8_t* data, size_t size)
1003 {
1004     pWifiDeviceServiceImpl->CheckCanEnableWifi();
1005 }
1006 
HilinkGetMacAddressTest(const uint8_t* data, size_t size)1007 void HilinkGetMacAddressTest(const uint8_t* data, size_t size)
1008 {
1009     WifiDeviceConfig config;
1010     int index = 0;
1011     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
1012     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
1013     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
1014     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
1015     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
1016     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
1017     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
1018     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
1019     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
1020     std::string currentMac = std::string(reinterpret_cast<const char*>(data), size);
1021     pWifiDeviceServiceImpl->HilinkGetMacAddress(config, currentMac);
1022 }
1023 
EnableHiLinkHandshakeTest(const uint8_t* data, size_t size)1024 void EnableHiLinkHandshakeTest(const uint8_t* data, size_t size)
1025 {
1026     WifiDeviceConfig config;
1027     int index = 0;
1028     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
1029     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
1030     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
1031     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
1032     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
1033     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
1034     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
1035     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
1036     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
1037     bool uiFlag = (static_cast<int>(data[0]) % TWO) ? true : false;
1038     std::string bssid = std::string(reinterpret_cast<const char*>(data), size);
1039     pWifiDeviceServiceImpl->EnableHiLinkHandshake(uiFlag, bssid, config);
1040 }
1041 
RegisterFilterBuilderTest(const uint8_t* data, size_t size)1042 void RegisterFilterBuilderTest(const uint8_t* data, size_t size)
1043 {
1044     FilterTag filterTag = static_cast<FilterTag>(static_cast<int>(data[0]) % FIVE);
1045     std::string bssid = std::string(reinterpret_cast<const char*>(data), size);
1046     FilterBuilder filterBuilder = [](auto &compositeWifiFilter) {};
1047     pWifiDeviceServiceImpl->RegisterFilterBuilder(filterTag, bssid, filterBuilder);
1048 }
1049 
1050 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)1051 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1052 {
1053     if ((data == nullptr) || (size <= OHOS::Wifi::U32_AT_SIZE_ZERO)) {
1054         return 0;
1055     }
1056     OHOS::Wifi::OnInitWifiProtectFuzzTest(data, size);
1057     OHOS::Wifi::OnGetWifiProtectRefFuzzTest(data, size);
1058     OHOS::Wifi::OnPutWifiProtectRefFuzzTest(data, size);
1059     OHOS::Wifi::OnIsHeldWifiProtectRefFuzzTest(data, size);
1060     OHOS::Wifi::OnAddDeviceConfigFuzzTest(data, size);
1061     OHOS::Wifi::OnUpdateDeviceConfigFuzzTest(data, size);
1062     OHOS::Wifi::OnRemoveDeviceFuzzTest(data, size);
1063     OHOS::Wifi::OnRemoveAllDeviceFuzzTest(data, size);
1064     OHOS::Wifi::OnGetDeviceConfigsFuzzTest(data, size);
1065     OHOS::Wifi::OnEnableDeviceConfigFuzzTest(data, size);
1066     OHOS::Wifi::OnDisableDeviceConfigFuzzTest(data, size);
1067     OHOS::Wifi::OnConnectToFuzzTest(data, size);
1068     OHOS::Wifi::OnConnect2ToFuzzTest(data, size);
1069     OHOS::Wifi::OnReConnectFuzzTest(data, size);
1070     OHOS::Wifi::OnReAssociateFuzzTest(data, size);
1071     OHOS::Wifi::OnDisconnectFuzzTest(data, size);
1072     OHOS::Wifi::OnStartWpsFuzzTest(data, size);
1073     OHOS::Wifi::OnCancelWpsFuzzTest(data, size);
1074     OHOS::Wifi::OnIsWifiActiveFuzzTest(data, size);
1075     OHOS::Wifi::OnGetWifiStateFuzzTest(data, size);
1076     OHOS::Wifi::OnIsMeteredHotspotFuzzTest(data, size);
1077     OHOS::Wifi::OnGetLinkedInfoFuzzTest(data, size);
1078     OHOS::Wifi::OnGetIpInfoFuzzTest(data, size);
1079     OHOS::Wifi::OnGetCountryCodeFuzzTest(data, size);
1080     OHOS::Wifi::OnRegisterCallBackFuzzTest(data, size);
1081     OHOS::Wifi::OnGetSignalLevelFuzzTest(data, size);
1082     OHOS::Wifi::OnGetIpV6InfoFuzzTest(data, size);
1083     OHOS::Wifi::OnGetDeviceMacAddFuzzTest(data, size);
1084     OHOS::Wifi::OnIsWifiConnectedFuzzTest(data, size);
1085     OHOS::Wifi::OnSetLowLatencyModeFuzzTest(data, size);
1086     OHOS::Wifi::OnRemoveCandidateConfigFuzzTest(data, size);
1087     OHOS::Wifi::OnIsBandTypeSupportedFuzzTest(data, size);
1088     OHOS::Wifi::OnGet5GHzChannelListFuzzTest(data, size);
1089     OHOS::Wifi::OnGetDisconnectedReasonFuzzTest(data, size);
1090     OHOS::Wifi::OnSetFrozenAppFuzzTest(data, size);
1091     OHOS::Wifi::OnResetAllFrozenAppFuzzTest(data, size);
1092     OHOS::Wifi::OnDisableAutoJoinFuzzTest(data, size);
1093     OHOS::Wifi::OnEnableAutoJoinFuzzTest(data, size);
1094     OHOS::Wifi::OnStartPortalCertificationFuzzTest(data, size);
1095     OHOS::Wifi::OnGetChangeDeviceConfigFuzzTest(data, size);
1096     OHOS::Wifi::OnLimitSpeedFuzzTest(data, size);
1097     OHOS::Wifi::OnEnableHiLinkHandshakeFuzzTest(data, size);
1098     OHOS::Wifi::OnGetWifiDetailStateFuzzTest(data, size);
1099     OHOS::Wifi::OnSetTxPowerFuzzTest(data, size);
1100     OHOS::Wifi::OnSetSatelliteStateFuzzTest(data, size);
1101     OHOS::Wifi::OnGetSupportedFeaturesFuzzTest(data, size);
1102     OHOS::Wifi::OnSetLowTxPowerTest(data, size);
1103     OHOS::Wifi::DoSomethingDeviceMgrStubTest(data, size);
1104     OHOS::Wifi::WifiDeviceServiceImplTest(data, size);
1105     OHOS::Wifi::CheckConfigEapTest(data, size);
1106     OHOS::Wifi::CheckConfigWapiTest(data, size);
1107     OHOS::Wifi::CheckConfigPwdTest(data, size);
1108     OHOS::Wifi::InitWifiBrokerProcessInfoTest(data, size);
1109     OHOS::Wifi::SetWifiConnectedModeTest(data, size);
1110     OHOS::Wifi::RemoveCandidateConfigFuzzTest(data, size);
1111     OHOS::Wifi::RemoveCandidateConfigTest(data, size);
1112     OHOS::Wifi::AddDeviceConfigTest(data, size);
1113     OHOS::Wifi::ConnectToNetworkTest(data, size);
1114     OHOS::Wifi::ConnectToDeviceTest(data, size);
1115     OHOS::Wifi::SaBasicDumpTest(data, size);
1116     OHOS::Wifi::IsRemoteDiedTest(data, size);
1117     OHOS::Wifi::IsBandTypeSupportedTest(data, size);
1118     OHOS::Wifi::RegisterCallBackTest(data, size);
1119     OHOS::Wifi::CheckCanEnableWifiTest(data, size);
1120     OHOS::Wifi::HilinkGetMacAddressTest(data, size);
1121     OHOS::Wifi::EnableHiLinkHandshakeTest(data, size);
1122     OHOS::Wifi::RegisterFilterBuilderTest(data, size);
1123     OHOS::Wifi::OnSetDpiMarkRuleTest(data, size);
1124     sleep(4);
1125     return 0;
1126 }
1127 }
1128 }
1129