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:
OnWifiStateChanged(int state)65     void OnWifiStateChanged(int state) override
66     {
67         LOGE("OnWifiStateChanged test");
68     }
69 
OnWifiConnectionChanged(int state,const WifiLinkedInfo & info)70     void OnWifiConnectionChanged(int state, const WifiLinkedInfo &info) override
71     {
72         LOGE("OnWifiConnectionChanged test");
73     }
74 
OnWifiRssiChanged(int rssi)75     void OnWifiRssiChanged(int rssi) override
76     {
77         LOGE("OnWifiRssiChanged test");
78     }
79 
OnWifiWpsStateChanged(int state,const std::string & pinCode)80     void OnWifiWpsStateChanged(int state, const std::string &pinCode) override
81     {
82         LOGE("OnWifiWpsStateChanged test");
83     }
84 
OnStreamChanged(int direction)85     void OnStreamChanged(int direction) override
86     {
87         LOGE("OnStreamChanged test");
88     }
89 
OnDeviceConfigChanged(ConfigChange value)90     void OnDeviceConfigChanged(ConfigChange value) override
91     {
92         LOGE("OnDeviceConfigChanged test");
93     }
94 
AsObject()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 
DoSomethingDeviceMgrStubTest(const uint8_t * data,size_t size)751 void DoSomethingDeviceMgrStubTest(const uint8_t* data, size_t size)
752 {
753     std::string networkName = "backup";
754     std::string name = "restore";
755     uint32_t code = static_cast<uint32_t>(DevInterfaceCode::WIFI_MGR_GET_DEVICE_SERVICE);
756     MessageParcel datas;
757     datas.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN_DEVICE_EX);
758     datas.WriteInt32(0);
759     datas.WriteBuffer(data, size);
760     datas.RewindRead(0);
761     MessageParcel reply;
762     MessageOption option;
763     WifiDeviceMgrServiceImpl mWifiDeviceMgrServiceImpl;
764     pWifiDeviceMgrStub->OnRemoteRequest(code, datas, reply, option);
765     mWifiDeviceMgrServiceImpl.OnExtension(networkName, datas, reply);
766     mWifiDeviceMgrServiceImpl.OnExtension(name, datas, reply);
767 }
768 
WifiFuzzTest()769 bool WifiFuzzTest()
770 {
771     return true;
772 }
773 
WifiDeviceServiceImplTest(const uint8_t * data,size_t size)774 void WifiDeviceServiceImplTest(const uint8_t* data, size_t size)
775 {
776     int index = 0;
777     int networkId = static_cast<int>(data[index++]);
778     int uid = static_cast<int>(data[index++]);
779     std::string networkName = std::string(reinterpret_cast<const char*>(data), size);
780     FilterTag filterTag = static_cast<FilterTag>(static_cast<int>(data[0]) % FIVE);
781     bool attemptEnable = (static_cast<int>(data[0]) % TWO) ? true : false;
782     WifiDeviceServiceImpl mWifiDeviceServiceImpl;
783     MessageParcel datas;
784     WifiDeviceConfig config;
785     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
786     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
787     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
788     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
789     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
790     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
791     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
792     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
793     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
794 
795     mWifiDeviceServiceImpl.DeregisterAutoJoinCondition(networkName);
796     mWifiDeviceServiceImpl.DeregisterFilterBuilder(filterTag, networkName);
797     mWifiDeviceServiceImpl.RegisterAutoJoinCondition(networkName, WifiFuzzTest);
798     mWifiDeviceServiceImpl.HilinkGetMacAddress(config, config.ssid);
799     mWifiDeviceServiceImpl.SaBasicDump(config.ssid);
800     mWifiDeviceServiceImpl.IsScanServiceRunning();
801     mWifiDeviceServiceImpl.StartRoamToNetwork(networkId, networkName, attemptEnable);
802     mWifiDeviceServiceImpl.IsWifiBrokerProcess(uid);
803     mWifiDeviceServiceImpl.CheckConfigPwd(config);
804     mWifiDeviceServiceImpl.CheckConfigEap(config);
805     pWifiDeviceStub->WriteEapConfig(datas, config.wifiEapConfig);
806     pWifiDeviceStub->WriteWifiDeviceConfig(datas, config);
807 }
808 
CheckConfigEapTest(const uint8_t * data,size_t size)809 void CheckConfigEapTest(const uint8_t* data, size_t size)
810 {
811     WifiDeviceConfig config;
812     int index = 0;
813     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
814     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
815     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
816     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
817     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
818     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
819     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
820     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
821     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
822     std::string keyMgmtWapiPsk = "WPA-PSK";
823     config.keyMgmt = keyMgmtWapiPsk;
824     pWifiDeviceServiceImpl->CheckConfigEap(config);
825     config.keyMgmt.clear();
826     std::string eapMethodPeap = "PEAP";
827     config.wifiEapConfig.eap = EAP_METHOD_PEAP;
828     pWifiDeviceServiceImpl->CheckConfigEap(config);
829     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
830     pWifiDeviceServiceImpl->CheckConfigEap(config);
831 }
832 
CheckConfigWapiTest(const uint8_t * data,size_t size)833 void CheckConfigWapiTest(const uint8_t* data, size_t size)
834 {
835     WifiDeviceConfig config;
836     int index = 0;
837     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
838     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
839     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
840     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
841     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
842     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
843     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
844     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
845     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
846     std::string keyMgmtwapiPsk = "WAPI-PSK";
847     config.keyMgmt = keyMgmtwapiPsk;
848     pWifiDeviceServiceImpl->CheckConfigWapi(config);
849     config.keyMgmt.clear();
850     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
851     pWifiDeviceServiceImpl->CheckConfigWapi(config);
852 }
853 
CheckConfigPwdTest(const uint8_t * data,size_t size)854 void CheckConfigPwdTest(const uint8_t* data, size_t size)
855 {
856     WifiDeviceConfig config;
857     int index = 0;
858     std::string ssidLength = "name";
859     config.ssid = ssidLength;
860     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
861     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
862     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
863     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
864     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
865     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
866     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
867     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
868     pWifiDeviceServiceImpl->CheckConfigPwd(config);
869 }
870 
InitWifiBrokerProcessInfoTest(const uint8_t * data,size_t size)871 void InitWifiBrokerProcessInfoTest(const uint8_t* data, size_t size)
872 {
873     WifiDeviceConfig config;
874     int index = 0;
875     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
876     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
877     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
878     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
879     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
880     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
881     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
882     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
883     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
884     std::string ancoServiceBroker = "anco_service_broker";
885     config.callProcessName = ancoServiceBroker;
886     pWifiDeviceServiceImpl->InitWifiBrokerProcessInfo(config);
887 }
888 
SetWifiConnectedModeTest(const uint8_t * data,size_t size)889 void SetWifiConnectedModeTest(const uint8_t* data, size_t size)
890 {
891     pWifiDeviceServiceImpl->SetWifiConnectedMode();
892 }
893 
RemoveCandidateConfigFuzzTest(const uint8_t * data,size_t size)894 void RemoveCandidateConfigFuzzTest(const uint8_t* data, size_t size)
895 {
896     WifiDeviceConfig config;
897     int index = 0;
898     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
899     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
900     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
901     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
902     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
903     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
904     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
905     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
906     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
907     config.callProcessName = std::string(reinterpret_cast<const char*>(data), size);
908     pWifiDeviceServiceImpl->RemoveCandidateConfig(config);
909 }
910 
RemoveCandidateConfigTest(const uint8_t * data,size_t size)911 void RemoveCandidateConfigTest(const uint8_t* data, size_t size)
912 {
913     int index = 0;
914     int networkId = static_cast<int>(data[index++]);
915     pWifiDeviceServiceImpl->RemoveCandidateConfig(networkId);
916 }
917 
AddDeviceConfigTest(const uint8_t * data,size_t size)918 void AddDeviceConfigTest(const uint8_t* data, size_t size)
919 {
920     WifiDeviceConfig config;
921     int result = 0;
922     int index = 0;
923     bool isCandidate = (static_cast<int>(data[0]) % TWO) ? true : false;
924     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
925     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
926     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
927     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
928     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
929     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
930     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
931     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
932     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
933     config.callProcessName = std::string(reinterpret_cast<const char*>(data), size);
934     pWifiDeviceServiceImpl->AddDeviceConfig(config, result, isCandidate);
935 }
936 
ConnectToNetworkTest(const uint8_t * data,size_t size)937 void ConnectToNetworkTest(const uint8_t* data, size_t size)
938 {
939     int index = 0;
940     int networkId = static_cast<int>(data[index++]);
941     bool isCandidate = (static_cast<int>(data[0]) % TWO) ? true : false;
942     pWifiDeviceServiceImpl->ConnectToNetwork(networkId, isCandidate);
943 }
944 
ConnectToDeviceTest(const uint8_t * data,size_t size)945 void ConnectToDeviceTest(const uint8_t* data, size_t size)
946 {
947     WifiDeviceConfig config;
948     int index = 0;
949     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
950     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
951     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
952     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
953     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
954     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
955     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
956     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
957     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
958     pWifiDeviceServiceImpl->ConnectToDevice(config);
959 }
960 
SaBasicDumpTest(const uint8_t * data,size_t size)961 void SaBasicDumpTest(const uint8_t* data, size_t size)
962 {
963     WifiLinkedInfo info;
964     info.connState = static_cast<ConnState>(static_cast<int>(data[0]) % NINE);
965     WifiConfigCenter::GetInstance().SaveLinkedInfo(info, 0);
966     std::string result;
967     pWifiDeviceServiceImpl->SaBasicDump(result);
968 }
969 
IsRemoteDiedTest(const uint8_t * data,size_t size)970 void IsRemoteDiedTest(const uint8_t* data, size_t size)
971 {
972     pWifiDeviceServiceImpl->IsRemoteDied();
973 }
974 
IsBandTypeSupportedTest(const uint8_t * data,size_t size)975 void IsBandTypeSupportedTest(const uint8_t* data, size_t size)
976 {
977     int bandType = static_cast<int>(data[0]);
978     bool supported = (static_cast<int>(data[0]) % TWO) ? true : false;
979     pWifiDeviceServiceImpl->IsBandTypeSupported(bandType, supported);
980 }
981 
RegisterCallBackTest(const uint8_t * data,size_t size)982 void RegisterCallBackTest(const uint8_t* data, size_t size)
983 {
984     std::vector<std::string> event;
985     sptr<IWifiDeviceCallBack> callBack = new (std::nothrow) IWifiDeviceCallBackMock();
986     pWifiDeviceServiceImpl->RegisterCallBack(callBack, event);
987     pWifiDeviceServiceImpl->RegisterCallBack(nullptr, event);
988 }
989 
CheckCanEnableWifiTest(const uint8_t * data,size_t size)990 void CheckCanEnableWifiTest(const uint8_t* data, size_t size)
991 {
992     pWifiDeviceServiceImpl->CheckCanEnableWifi();
993 }
994 
HilinkGetMacAddressTest(const uint8_t * data,size_t size)995 void HilinkGetMacAddressTest(const uint8_t* data, size_t size)
996 {
997     WifiDeviceConfig config;
998     int index = 0;
999     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
1000     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
1001     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
1002     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
1003     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
1004     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
1005     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
1006     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
1007     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
1008     std::string currentMac = std::string(reinterpret_cast<const char*>(data), size);
1009     pWifiDeviceServiceImpl->HilinkGetMacAddress(config, currentMac);
1010 }
1011 
EnableHiLinkHandshakeTest(const uint8_t * data,size_t size)1012 void EnableHiLinkHandshakeTest(const uint8_t* data, size_t size)
1013 {
1014     WifiDeviceConfig config;
1015     int index = 0;
1016     config.ssid = std::string(reinterpret_cast<const char*>(data), size);
1017     config.bssid = std::string(reinterpret_cast<const char*>(data), size);
1018     config.preSharedKey = std::string(reinterpret_cast<const char*>(data), size);
1019     config.keyMgmt = std::string(reinterpret_cast<const char*>(data), size);
1020     config.wifiEapConfig.eap = std::string(reinterpret_cast<const char*>(data), size);
1021     config.wifiEapConfig.clientCert = std::string(reinterpret_cast<const char*>(data), size);
1022     config.wifiEapConfig.privateKey = std::string(reinterpret_cast<const char*>(data), size);
1023     config.wifiEapConfig.certEntry.push_back(static_cast<uint8_t>(data[index++]));
1024     config.wifiEapConfig.encryptedData = std::string(reinterpret_cast<const char*>(data), size);
1025     bool uiFlag = (static_cast<int>(data[0]) % TWO) ? true : false;
1026     std::string bssid = std::string(reinterpret_cast<const char*>(data), size);
1027     pWifiDeviceServiceImpl->EnableHiLinkHandshake(uiFlag, bssid, config);
1028 }
1029 
RegisterFilterBuilderTest(const uint8_t * data,size_t size)1030 void RegisterFilterBuilderTest(const uint8_t* data, size_t size)
1031 {
1032     FilterTag filterTag = static_cast<FilterTag>(static_cast<int>(data[0]) % FIVE);
1033     std::string bssid = std::string(reinterpret_cast<const char*>(data), size);
1034     FilterBuilder filterBuilder = [](auto &compositeWifiFilter) {};
1035     pWifiDeviceServiceImpl->RegisterFilterBuilder(filterTag, bssid, filterBuilder);
1036 }
1037 
1038 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1039 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1040 {
1041     if ((data == nullptr) || (size <= OHOS::Wifi::U32_AT_SIZE_ZERO)) {
1042         return 0;
1043     }
1044     OHOS::Wifi::OnInitWifiProtectFuzzTest(data, size);
1045     OHOS::Wifi::OnGetWifiProtectRefFuzzTest(data, size);
1046     OHOS::Wifi::OnPutWifiProtectRefFuzzTest(data, size);
1047     OHOS::Wifi::OnIsHeldWifiProtectRefFuzzTest(data, size);
1048     OHOS::Wifi::OnAddDeviceConfigFuzzTest(data, size);
1049     OHOS::Wifi::OnUpdateDeviceConfigFuzzTest(data, size);
1050     OHOS::Wifi::OnRemoveDeviceFuzzTest(data, size);
1051     OHOS::Wifi::OnRemoveAllDeviceFuzzTest(data, size);
1052     OHOS::Wifi::OnGetDeviceConfigsFuzzTest(data, size);
1053     OHOS::Wifi::OnEnableDeviceConfigFuzzTest(data, size);
1054     OHOS::Wifi::OnDisableDeviceConfigFuzzTest(data, size);
1055     OHOS::Wifi::OnConnectToFuzzTest(data, size);
1056     OHOS::Wifi::OnConnect2ToFuzzTest(data, size);
1057     OHOS::Wifi::OnReConnectFuzzTest(data, size);
1058     OHOS::Wifi::OnReAssociateFuzzTest(data, size);
1059     OHOS::Wifi::OnDisconnectFuzzTest(data, size);
1060     OHOS::Wifi::OnStartWpsFuzzTest(data, size);
1061     OHOS::Wifi::OnCancelWpsFuzzTest(data, size);
1062     OHOS::Wifi::OnIsWifiActiveFuzzTest(data, size);
1063     OHOS::Wifi::OnGetWifiStateFuzzTest(data, size);
1064     OHOS::Wifi::OnIsMeteredHotspotFuzzTest(data, size);
1065     OHOS::Wifi::OnGetLinkedInfoFuzzTest(data, size);
1066     OHOS::Wifi::OnGetIpInfoFuzzTest(data, size);
1067     OHOS::Wifi::OnGetCountryCodeFuzzTest(data, size);
1068     OHOS::Wifi::OnRegisterCallBackFuzzTest(data, size);
1069     OHOS::Wifi::OnGetSignalLevelFuzzTest(data, size);
1070     OHOS::Wifi::OnGetIpV6InfoFuzzTest(data, size);
1071     OHOS::Wifi::OnGetDeviceMacAddFuzzTest(data, size);
1072     OHOS::Wifi::OnIsWifiConnectedFuzzTest(data, size);
1073     OHOS::Wifi::OnSetLowLatencyModeFuzzTest(data, size);
1074     OHOS::Wifi::OnRemoveCandidateConfigFuzzTest(data, size);
1075     OHOS::Wifi::OnIsBandTypeSupportedFuzzTest(data, size);
1076     OHOS::Wifi::OnGet5GHzChannelListFuzzTest(data, size);
1077     OHOS::Wifi::OnGetDisconnectedReasonFuzzTest(data, size);
1078     OHOS::Wifi::OnSetFrozenAppFuzzTest(data, size);
1079     OHOS::Wifi::OnResetAllFrozenAppFuzzTest(data, size);
1080     OHOS::Wifi::OnDisableAutoJoinFuzzTest(data, size);
1081     OHOS::Wifi::OnEnableAutoJoinFuzzTest(data, size);
1082     OHOS::Wifi::OnStartPortalCertificationFuzzTest(data, size);
1083     OHOS::Wifi::OnGetChangeDeviceConfigFuzzTest(data, size);
1084     OHOS::Wifi::OnLimitSpeedFuzzTest(data, size);
1085     OHOS::Wifi::OnEnableHiLinkHandshakeFuzzTest(data, size);
1086     OHOS::Wifi::OnGetWifiDetailStateFuzzTest(data, size);
1087     OHOS::Wifi::OnSetTxPowerFuzzTest(data, size);
1088     OHOS::Wifi::OnSetSatelliteStateFuzzTest(data, size);
1089     OHOS::Wifi::OnGetSupportedFeaturesFuzzTest(data, size);
1090     OHOS::Wifi::OnSetLowTxPowerTest(data, size);
1091     OHOS::Wifi::DoSomethingDeviceMgrStubTest(data, size);
1092     OHOS::Wifi::WifiDeviceServiceImplTest(data, size);
1093     OHOS::Wifi::CheckConfigEapTest(data, size);
1094     OHOS::Wifi::CheckConfigWapiTest(data, size);
1095     OHOS::Wifi::CheckConfigPwdTest(data, size);
1096     OHOS::Wifi::InitWifiBrokerProcessInfoTest(data, size);
1097     OHOS::Wifi::SetWifiConnectedModeTest(data, size);
1098     OHOS::Wifi::RemoveCandidateConfigFuzzTest(data, size);
1099     OHOS::Wifi::RemoveCandidateConfigTest(data, size);
1100     OHOS::Wifi::AddDeviceConfigTest(data, size);
1101     OHOS::Wifi::ConnectToNetworkTest(data, size);
1102     OHOS::Wifi::ConnectToDeviceTest(data, size);
1103     OHOS::Wifi::SaBasicDumpTest(data, size);
1104     OHOS::Wifi::IsRemoteDiedTest(data, size);
1105     OHOS::Wifi::IsBandTypeSupportedTest(data, size);
1106     OHOS::Wifi::RegisterCallBackTest(data, size);
1107     OHOS::Wifi::CheckCanEnableWifiTest(data, size);
1108     OHOS::Wifi::HilinkGetMacAddressTest(data, size);
1109     OHOS::Wifi::EnableHiLinkHandshakeTest(data, size);
1110     OHOS::Wifi::RegisterFilterBuilderTest(data, size);
1111     sleep(4);
1112     return 0;
1113 }
1114 }
1115 }
1116