1 /*
2 * Copyright (c) 2022-2025 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 <cstddef>
17 #include <cstdint>
18 #include <fuzzer/FuzzedDataProvider.h>
19 #include <string>
20 #include <unistd.h>
21
22 #include "device_manager.h"
23 #include "device_manager_callback.h"
24 #include "device_manager_impl.h"
25 #include "dm_crypto.h"
26 #include "accesstoken_kit.h"
27 #include "authenticate_device_fuzzer.h"
28 #include "nativetoken_kit.h"
29 #include "token_setproc.h"
30 #include "dm_constants.h"
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 class AuthenticateCallbackTest : public AuthenticateCallback {
35 public:
~AuthenticateCallbackTest()36 virtual ~AuthenticateCallbackTest() {}
OnAuthResult(const std::string & deviceId,const std::string & token,int32_t status,int32_t reason)37 void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status,
38 int32_t reason) override {}
39 };
40
41 class DmInitCallbackTest : public DmInitCallback {
42 public:
DmInitCallbackTest()43 DmInitCallbackTest() : DmInitCallback() {}
~DmInitCallbackTest()44 virtual ~DmInitCallbackTest() {}
OnRemoteDied()45 void OnRemoteDied() override {}
46 };
47
48 class DeviceStateCallbackTest : public DeviceStateCallback {
49 public:
DeviceStateCallbackTest()50 DeviceStateCallbackTest() : DeviceStateCallback() {}
~DeviceStateCallbackTest()51 virtual ~DeviceStateCallbackTest() {}
OnDeviceOnline(const DmDeviceInfo & deviceInfo)52 void OnDeviceOnline(const DmDeviceInfo &deviceInfo) override {}
OnDeviceReady(const DmDeviceInfo & deviceInfo)53 void OnDeviceReady(const DmDeviceInfo &deviceInfo) override {}
OnDeviceOffline(const DmDeviceInfo & deviceInfo)54 void OnDeviceOffline(const DmDeviceInfo &deviceInfo) override {}
OnDeviceChanged(const DmDeviceInfo & deviceInfo)55 void OnDeviceChanged(const DmDeviceInfo &deviceInfo) override {}
56 };
57
58 class DeviceStatusCallbackTest : public DeviceStatusCallback {
59 public:
~DeviceStatusCallbackTest()60 virtual ~DeviceStatusCallbackTest() { }
OnDeviceOnline(const DmDeviceBasicInfo & deviceBasicInfo)61 void OnDeviceOnline(const DmDeviceBasicInfo &deviceBasicInfo) override {}
OnDeviceOffline(const DmDeviceBasicInfo & deviceBasicInfo)62 void OnDeviceOffline(const DmDeviceBasicInfo &deviceBasicInfo) override {}
OnDeviceChanged(const DmDeviceBasicInfo & deviceBasicInfo)63 void OnDeviceChanged(const DmDeviceBasicInfo &deviceBasicInfo) override {}
OnDeviceReady(const DmDeviceBasicInfo & deviceBasicInfo)64 void OnDeviceReady(const DmDeviceBasicInfo &deviceBasicInfo) override {}
65 };
66
67 class DeviceDiscoveryCallbackTest : public DiscoveryCallback {
68 public:
DeviceDiscoveryCallbackTest()69 DeviceDiscoveryCallbackTest() : DiscoveryCallback() {}
~DeviceDiscoveryCallbackTest()70 virtual ~DeviceDiscoveryCallbackTest() {}
OnDiscoverySuccess(uint16_t subscribeId)71 void OnDiscoverySuccess(uint16_t subscribeId) override {}
OnDiscoveryFailed(uint16_t subscribeId,int32_t failedReason)72 void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) override {}
OnDeviceFound(uint16_t subscribeId,const DmDeviceInfo & deviceInfo)73 void OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override {}
OnDeviceFound(uint16_t subscribeId,const DmDeviceBasicInfo & deviceBasicInfo)74 void OnDeviceFound(uint16_t subscribeId, const DmDeviceBasicInfo &deviceBasicInfo) override{}
75 };
76
77 class DevicePublishCallbackTest : public PublishCallback {
78 public:
DevicePublishCallbackTest()79 DevicePublishCallbackTest() : PublishCallback() {}
~DevicePublishCallbackTest()80 virtual ~DevicePublishCallbackTest() {}
OnPublishResult(int32_t publishId,int32_t failedReason)81 void OnPublishResult(int32_t publishId, int32_t failedReason) override {}
82 };
83
84 class DeviceManagerUiCallbackTest : public DeviceManagerUiCallback {
85 public:
~DeviceManagerUiCallbackTest()86 virtual ~DeviceManagerUiCallbackTest() {}
OnCall(const std::string & paramJson)87 void OnCall(const std::string ¶mJson) override {}
88 };
89
90 class DeviceScreenStatusCallbackTest : public DeviceScreenStatusCallback {
91 public:
~DeviceScreenStatusCallbackTest()92 virtual ~DeviceScreenStatusCallbackTest() {}
OnDeviceScreenStatus(const DmDeviceInfo & deviceInfo)93 void OnDeviceScreenStatus(const DmDeviceInfo &deviceInfo) override {}
94 };
95
96 std::string g_returnStr;
97 std::string g_reqJsonStr = R"(
98 {
99 "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
100 }
101 )";
102
103 std::string g_credentialInfo = R"(
104 {
105 "processType" : 1,
106 "g_authType" : 1,
107 "userId" : "123",
108 "credentialData" :
109 [
110 {
111 "credentialType" : 1,
112 "credentialId" : "104",
113 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
114 "serverPk" : "",
115 "pkInfoSignature" : "",
116 "pkInfo" : "",
117 "peerDeviceId" : ""
118 }
119 ]
120 }
121 )";
122
123 std::string g_deleteInfo = R"(
124 {
125 "processType" : 1,
126 "g_authType" : 1,
127 "userId" : "123"
128 }
129 )";
130
131 DmDeviceInfo g_deviceInfo = {
132 .deviceId = "123456789101112131415",
133 .deviceName = "deviceName",
134 .deviceTypeId = 1
135 };
136
137 DmSubscribeInfo g_subscribeInfo = {
138 .subscribeId = 0,
139 .mode = DmDiscoverMode::DM_DISCOVER_MODE_ACTIVE,
140 .medium = DmExchangeMedium::DM_AUTO,
141 .freq = DmExchangeFreq::DM_MID,
142 .isSameAccount = true,
143 .isWakeRemote = true,
144 };
145
146 DmPublishInfo g_publishInfo = {
147 .publishId = 1234,
148 .mode = DmDiscoverMode::DM_DISCOVER_MODE_ACTIVE,
149 .freq = DmExchangeFreq::DM_MID,
150 .ranging = true,
151 };
152
153 PeerTargetId g_targetId = {
154 .deviceId = "deviceId",
155 .brMac = "brMac",
156 .bleMac = "bleMac",
157 .wifiIp = "wifiIp",
158 };
159
160 DmDeviceInfo g_getDeviceInfo;
161 DmPinType g_pinType = DmPinType::SUPER_SONIC;
162
163 uint64_t g_tokenId = 1;
164 int32_t g_authType = -1;
165 int32_t g_action = 2;
166 int32_t g_eventId = 1;
167 int32_t g_bindType = 1;
168 int32_t g_securityLevel = 1;
169 int64_t g_accessControlId = 1;
170
171 bool g_isRefresh = false;
172
173 std::vector<DmDeviceInfo> g_deviceList;
174 std::vector<DmDeviceBasicInfo> g_deviceBasic;
175
176 std::shared_ptr<DmInitCallback> g_initcallback = std::make_shared<DmInitCallbackTest>();
177 std::shared_ptr<DeviceStateCallback> g_stateCallback = std::make_shared<DeviceStateCallbackTest>();
178 std::shared_ptr<AuthenticateCallback> g_callbackk = std::make_shared<AuthenticateCallbackTest>();
179 std::shared_ptr<DeviceStatusCallback> g_statusCallback = std::make_shared<DeviceStatusCallbackTest>();
180 std::shared_ptr<DiscoveryCallback> g_discoveryCallback = std::make_shared<DeviceDiscoveryCallbackTest>();
181 std::shared_ptr<PublishCallback> g_publishCallback = std::make_shared<DevicePublishCallbackTest>();
182 std::shared_ptr<DeviceManagerUiCallback> g_Uicallback = std::make_shared<DeviceManagerUiCallbackTest>();
183
AddPermission()184 void AddPermission()
185 {
186 const int32_t permsNum = 3;
187 const int32_t indexZero = 0;
188 const int32_t indexOne = 1;
189 const int32_t indexTwo = 2;
190 uint64_t tokenId;
191 const char *perms[permsNum];
192 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
193 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
194 perms[indexTwo] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
195 NativeTokenInfoParams infoInstance = {
196 .dcapsNum = 0,
197 .permsNum = permsNum,
198 .aclsNum = 0,
199 .dcaps = NULL,
200 .perms = perms,
201 .acls = NULL,
202 .processName = "device_manager",
203 .aplStr = "system_core",
204 };
205 tokenId = GetAccessTokenId(&infoInstance);
206 SetSelfTokenID(tokenId);
207 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
208 }
209
AuthenticateDeviceFirstFuzzTest(const uint8_t * data,size_t size)210 void AuthenticateDeviceFirstFuzzTest(const uint8_t* data, size_t size)
211 {
212 if ((data == nullptr) || (size == 0)) {
213 return;
214 }
215 AddPermission();
216 std::string str(reinterpret_cast<const char*>(data), size);
217
218 DeviceManagerImpl::GetInstance().ipcClientProxy_ =
219 std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
220
221 DeviceManager::GetInstance().InitDeviceManager(str, g_initcallback);
222 DeviceManager::GetInstance().RegisterDevStateCallback(str, str, g_stateCallback);
223 DeviceManager::GetInstance().RegisterDevStatusCallback(str, str, g_statusCallback);
224 DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(str, g_Uicallback);
225 std::string emptyStr = "";
226 DeviceManager::GetInstance().RegisterDevStateCallback(emptyStr, str, g_stateCallback);
227 DeviceManager::GetInstance().AuthenticateDevice(str, g_authType, g_deviceInfo, emptyStr, g_callbackk);
228 DeviceManager::GetInstance().UnAuthenticateDevice(str, g_deviceInfo);
229 strncpy_s(g_deviceInfo.networkId, sizeof(g_deviceInfo.networkId), "networkId", sizeof(g_deviceInfo.networkId) - 1);
230 g_deviceInfo.networkId[sizeof(g_deviceInfo.networkId) - 1] = '\0';
231 DeviceManager::GetInstance().UnAuthenticateDevice(str, g_deviceInfo);
232 std::string pkgName = "pkgName";
233 DeviceManager::GetInstance().StartDeviceDiscovery(pkgName, g_subscribeInfo, pkgName, g_discoveryCallback);
234 DeviceManager::GetInstance().StopDeviceDiscovery(str, g_subscribeInfo.subscribeId);
235 DeviceManager::GetInstance().StartDeviceDiscovery(pkgName, g_tokenId, pkgName, g_discoveryCallback);
236 DeviceManager::GetInstance().StopDeviceDiscovery(g_tokenId, str);
237 DeviceManager::GetInstance().PublishDeviceDiscovery(str, g_publishInfo, g_publishCallback);
238 DeviceManager::GetInstance().UnPublishDeviceDiscovery(str, g_publishInfo.publishId);
239 DeviceManager::GetInstance().UnInitDeviceManager(str);
240 }
241
AuthenticateDeviceSecondFuzzTest(const uint8_t * data,size_t size)242 void AuthenticateDeviceSecondFuzzTest(const uint8_t* data, size_t size)
243 {
244 if ((data == nullptr) || (size == 0)) {
245 return;
246 }
247 AddPermission();
248 std::string str(reinterpret_cast<const char*>(data), size);
249
250 DeviceManagerImpl::GetInstance().ipcClientProxy_ =
251 std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
252
253 DeviceManager::GetInstance().GetTrustedDeviceList(str, str, g_deviceList);
254 DeviceManager::GetInstance().GetTrustedDeviceList(str, str, g_isRefresh, g_deviceList);
255 DeviceManager::GetInstance().GetAvailableDeviceList(str, g_deviceBasic);
256 DeviceManager::GetInstance().GetDeviceInfo(str, str, g_getDeviceInfo);
257 DeviceManager::GetInstance().GetLocalDeviceInfo(str, g_getDeviceInfo);
258 DeviceManager::GetInstance().GetUdidByNetworkId(str, str, g_returnStr);
259 DeviceManager::GetInstance().GetUuidByNetworkId(str, str, g_returnStr);
260 DeviceManager::GetInstance().DpAclAdd(g_accessControlId, str, g_bindType);
261 DeviceManager::GetInstance().DpAclAdd(g_accessControlId, str, INVALID_TYPE);
262 DeviceManager::GetInstance().CreatePinHolder(str, g_targetId, g_pinType, str);
263 DeviceManager::GetInstance().DestroyPinHolder(str, g_targetId, g_pinType, str);
264 DeviceManager::GetInstance().CheckAccessToTarget(g_tokenId, str);
265 DeviceManager::GetInstance().IsSameAccount(str);
266 }
267
AuthenticateDeviceThirdFuzzTest(const uint8_t * data,size_t size)268 void AuthenticateDeviceThirdFuzzTest(const uint8_t* data, size_t size)
269 {
270 if ((data == nullptr) || (size == 0)) {
271 return;
272 }
273 AddPermission();
274 std::string str = Crypto::Sha256(data, size);
275
276 DeviceManagerImpl::GetInstance().ipcClientProxy_ =
277 std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
278
279 DeviceManager::GetInstance().SetUserOperation(str, g_action, str);
280 DeviceManager::GetInstance().RequestCredential(str, g_returnStr);
281 DeviceManager::GetInstance().RequestCredential(str, g_reqJsonStr, g_returnStr);
282 DeviceManager::GetInstance().ImportCredential(str, g_credentialInfo);
283 DeviceManager::GetInstance().DeleteCredential(str, g_deleteInfo);
284 DeviceManager::GetInstance().CheckCredential(str, g_reqJsonStr, g_returnStr);
285 DeviceManager::GetInstance().ImportCredential(str, g_reqJsonStr, g_returnStr);
286 DeviceManager::GetInstance().DeleteCredential(str, g_reqJsonStr, g_returnStr);
287 DeviceManager::GetInstance().NotifyEvent(str, g_eventId, str);
288 std::string emptyStr = "";
289 DeviceManager::GetInstance().BindDevice(str, g_authType, str, emptyStr, g_callbackk);
290 DeviceManager::GetInstance().UnBindDevice(str, g_deviceInfo.deviceId);
291 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(str);
292 DeviceManager::GetInstance().UnRegisterDevStateCallback(str);
293 DeviceManager::GetInstance().UnRegisterDevStateCallback(emptyStr);
294 DeviceManager::GetInstance().UnRegisterDevStatusCallback(str);
295 std::map<std::string, std::string> authParam;
296 authParam[DM_AUTHENTICATION_TYPE] = str;
297 DeviceManager::GetInstance().RegisterAuthenticationType(str, authParam);
298 DeviceManager::GetInstance().RegisterAuthenticationType(emptyStr, authParam);
299 }
300
AuthenticateDeviceFourthFuzzTest(const uint8_t * data,size_t size)301 void AuthenticateDeviceFourthFuzzTest(const uint8_t* data, size_t size)
302 {
303 if ((data == nullptr) || (size == 0)) {
304 return;
305 }
306 AddPermission();
307 std::string str(reinterpret_cast<const char*>(data), size);
308 DeviceManagerImpl::GetInstance().ipcClientProxy_ =
309 std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
310 std::string emptyStr = "";
311 DmDeviceInfo info;
312 DmDeviceBasicInfo deviceBasicInfo;
313 int32_t indexTwo = 2;
314 int32_t numOne = 1;
315 int32_t numOneTwoTimes = 11;
316 int32_t numOneThreeTimes = 111;
317 int32_t numOneSixTimes = 111111;
318 DeviceManagerImpl::GetInstance().ConvertDeviceInfoToDeviceBasicInfo(info, deviceBasicInfo);
319 DeviceManagerImpl::GetInstance().GetTrustedDeviceList(str, emptyStr, g_deviceList);
320 DeviceManagerImpl::GetInstance().GetTrustedDeviceList(str, emptyStr, false, g_deviceList);
321 DeviceManagerImpl::GetInstance().GetDeviceInfo(str, emptyStr, info);
322 DeviceManagerImpl::GetInstance().RegisterDevStatusCallback(str, emptyStr, nullptr);
323 DeviceManagerImpl::GetInstance().UnRegisterDevStateCallback(str);
324 DeviceManagerImpl::GetInstance().UnRegisterDevStatusCallback(emptyStr);
325 DeviceManagerImpl::GetInstance().StartDeviceDiscovery(str, g_subscribeInfo, emptyStr, nullptr);
326 DeviceManagerImpl::GetInstance().StartDeviceDiscovery(str, numOneSixTimes, emptyStr, nullptr);
327 DeviceManagerImpl::GetInstance().StopDeviceDiscovery(str, numOneTwoTimes);
328 DeviceManagerImpl::GetInstance().StopDeviceDiscovery(emptyStr, numOneTwoTimes);
329 DeviceManagerImpl::GetInstance().StopDeviceDiscovery(numOneThreeTimes, "");
330 DeviceManagerImpl::GetInstance().PublishDeviceDiscovery(str, g_publishInfo, nullptr);
331 DeviceManagerImpl::GetInstance().UnPublishDeviceDiscovery(str, numOneTwoTimes);
332 DeviceManagerImpl::GetInstance().UnPublishDeviceDiscovery(emptyStr, numOneTwoTimes);
333 DeviceManagerImpl::GetInstance().AuthenticateDevice(str, numOne, info, emptyStr, nullptr);
334 DeviceManagerImpl::GetInstance().RegisterDeviceManagerFaCallback(str, nullptr);
335 DeviceManagerImpl::GetInstance().UnRegisterDeviceManagerFaCallback(str);
336 DeviceManagerImpl::GetInstance().VerifyAuthentication(str, emptyStr, nullptr);
337 PeerTargetId targetId;
338 std::map<std::string, std::string> discoverParam;
339 DeviceManagerImpl::GetInstance().BindTarget(str, targetId, discoverParam, nullptr);
340 DeviceManagerImpl::GetInstance().UnbindTarget(str, targetId, discoverParam, nullptr);
341 DeviceManagerImpl::GetInstance().GetTrustedDeviceList(str, discoverParam, false, g_deviceList);
342 DeviceManagerImpl::GetInstance().RegisterDevStateCallback(str, discoverParam, nullptr);
343 DeviceManagerImpl::GetInstance().AddDiscoveryCallback("test", discoverParam, nullptr);
344 DeviceManagerImpl::GetInstance().RemoveDiscoveryCallback("test");
345 DeviceManagerImpl::GetInstance().AddPublishCallback("test");
346 DeviceManagerImpl::GetInstance().RemovePublishCallback("test");
347 DeviceManagerImpl::GetInstance().RegisterPinHolderCallback(str, nullptr);
348 DeviceManagerImpl::GetInstance().GetDeviceSecurityLevel(str, emptyStr, indexTwo);
349 DeviceManagerImpl::GetInstance().GetDeviceSecurityLevel(str, str, indexTwo);
350 DeviceManagerImpl::GetInstance().IsSameAccount(emptyStr);
351 }
352
AuthenticateDeviceFifthFuzzTest(const uint8_t * data,size_t size)353 void AuthenticateDeviceFifthFuzzTest(const uint8_t* data, size_t size)
354 {
355 if ((data == nullptr) || (size == 0)) {
356 return;
357 }
358 AddPermission();
359 std::string str(reinterpret_cast<const char*>(data), size);
360
361 DeviceManagerImpl::GetInstance().ipcClientProxy_ =
362 std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
363 std::string emptyStr = "";
364 DmDeviceInfo info;
365 DmDeviceBasicInfo deviceBasicInfo;
366 int32_t indexTwo = 2;
367 DmAuthParam dmFaParam;
368 DeviceManagerImpl::GetInstance().GetFaParam(str, dmFaParam);
369 DeviceManagerImpl::GetInstance().SetUserOperation(str, 1, emptyStr);
370 DeviceManagerImpl::GetInstance().GetUdidByNetworkId(str, emptyStr, g_returnStr);
371 DeviceManagerImpl::GetInstance().GetUuidByNetworkId(str, emptyStr, g_returnStr);
372 DeviceManagerImpl::GetInstance().RegisterDevStateCallback(str, emptyStr);
373 DeviceManagerImpl::GetInstance().UnRegisterDevStateCallback(str, emptyStr);
374 DeviceManagerImpl::GetInstance().RegisterUiStateCallback(str);
375 DeviceManagerImpl::GetInstance().RegisterUiStateCallback(emptyStr);
376 DeviceManagerImpl::GetInstance().UnRegisterUiStateCallback(emptyStr);
377 DeviceManagerImpl::GetInstance().UnRegisterUiStateCallback(str);
378 DeviceManagerImpl::GetInstance().RequestCredential(emptyStr, g_reqJsonStr, g_returnStr);
379 DeviceManagerImpl::GetInstance().RequestCredential(str, g_reqJsonStr, g_returnStr);
380 DeviceManagerImpl::GetInstance().ImportCredential(str, emptyStr);
381 DeviceManagerImpl::GetInstance().DeleteCredential(str, emptyStr);
382 DeviceManagerImpl::GetInstance().RegisterCredentialCallback(str, nullptr);
383 DeviceManagerImpl::GetInstance().UnRegisterCredentialCallback(emptyStr);
384 DeviceManagerImpl::GetInstance().UnRegisterCredentialCallback(str);
385 DeviceManagerImpl::GetInstance().NotifyEvent(emptyStr, 1, emptyStr);
386 DeviceManagerImpl::GetInstance().NotifyEvent(str, 1, emptyStr);
387 DeviceManagerImpl::GetInstance().RequestCredential(emptyStr, g_returnStr);
388 DeviceManagerImpl::GetInstance().RequestCredential(str, g_returnStr);
389 DeviceManagerImpl::GetInstance().CheckCredential(emptyStr, g_reqJsonStr, g_returnStr);
390 DeviceManagerImpl::GetInstance().CheckCredential(str, g_reqJsonStr, g_returnStr);
391 DeviceManagerImpl::GetInstance().GetEncryptedUuidByNetworkId(str, emptyStr, g_returnStr);
392 DeviceManagerImpl::GetInstance().GenerateEncryptedUuid(str, emptyStr, emptyStr, g_returnStr);
393 DeviceManagerImpl::GetInstance().BindDevice(str, 1, emptyStr, emptyStr, nullptr);
394 DeviceManagerImpl::GetInstance().UnBindDevice(str, emptyStr);
395 DeviceManagerImpl::GetInstance().GetNetworkTypeByNetworkId(str, emptyStr, indexTwo);
396 DeviceManagerImpl::GetInstance().GetNetworkTypeByNetworkId(str, str, indexTwo);
397 DeviceManagerImpl::GetInstance().ImportAuthCode(emptyStr, emptyStr);
398 DeviceManagerImpl::GetInstance().ImportAuthCode(str, str);
399 std::string authCode = "123456";
400 DeviceManagerImpl::GetInstance().ImportAuthCode(str, authCode);
401 DeviceManagerImpl::GetInstance().ExportAuthCode(g_returnStr);
402 }
403
AuthenticateDeviceSixthFuzzTest(const uint8_t * data,size_t size)404 void AuthenticateDeviceSixthFuzzTest(const uint8_t* data, size_t size)
405 {
406 int32_t maxStringLength = 10;
407 size_t requiredSize = maxStringLength * 9;
408 if ((data == nullptr) || (size < requiredSize)) {
409 return;
410 }
411 AddPermission();
412 FuzzedDataProvider fdp(data, size);
413 std::string str = fdp.ConsumeRandomLengthString();
414
415 std::string emptyStr = "";
416 int32_t indexTwo = 2;
417 std::map<std::string, std::string> discoverParam;
418 std::map<std::string, std::string> policy;
419 policy[fdp.ConsumeRandomLengthString(maxStringLength)] = fdp.ConsumeRandomLengthString(maxStringLength);
420 policy[fdp.ConsumeRandomLengthString(maxStringLength)] = fdp.ConsumeRandomLengthString(maxStringLength);
421 DeviceManagerImpl::GetInstance().StartDiscovering(str, discoverParam, discoverParam, nullptr);
422 DeviceManagerImpl::GetInstance().StopDiscovering(str, discoverParam);
423 DeviceManagerImpl::GetInstance().StopDiscovering(emptyStr, discoverParam);
424 DeviceManagerImpl::GetInstance().RegisterDiscoveryCallback(str, discoverParam, discoverParam, g_discoveryCallback);
425 DeviceManagerImpl::GetInstance().RegisterDiscoveryCallback(str, discoverParam, discoverParam, nullptr);
426 DeviceManagerImpl::GetInstance().UnRegisterDiscoveryCallback(str);
427 DeviceManagerImpl::GetInstance().UnRegisterDiscoveryCallback(emptyStr);
428 DeviceManagerImpl::GetInstance().StartAdvertising(str, discoverParam, nullptr);
429 DeviceManagerImpl::GetInstance().StartAdvertising(str, discoverParam, g_publishCallback);
430 DeviceManagerImpl::GetInstance().StopAdvertising(emptyStr, discoverParam);
431 DeviceManagerImpl::GetInstance().StopAdvertising(str, discoverParam);
432 DeviceManagerImpl::GetInstance().SetDnPolicy(str, discoverParam);
433 DeviceManagerImpl::GetInstance().SetDnPolicy(str, policy);
434 DeviceManagerImpl::GetInstance().RegisterDeviceScreenStatusCallback(emptyStr, nullptr);
435 DeviceManagerImpl::GetInstance().UnRegisterDeviceScreenStatusCallback(emptyStr);
436 std::shared_ptr<DeviceScreenStatusCallback> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
437 DeviceManagerImpl::GetInstance().RegisterDeviceScreenStatusCallback(str, callback);
438 DeviceManagerImpl::GetInstance().UnRegisterDeviceScreenStatusCallback(str);
439 DeviceManagerImpl::GetInstance().GetDeviceScreenStatus(emptyStr, emptyStr, indexTwo);
440 DeviceManagerImpl::GetInstance().GetDeviceScreenStatus(str, str, indexTwo);
441 PeerTargetId targetId;
442 targetId.deviceId = fdp.ConsumeRandomLengthString(maxStringLength);
443 targetId.brMac = fdp.ConsumeRandomLengthString(maxStringLength);
444 targetId.bleMac = fdp.ConsumeRandomLengthString(maxStringLength);
445 targetId.wifiIp = fdp.ConsumeRandomLengthString(maxStringLength);
446 DeviceManagerImpl::GetInstance().BindTarget(str, targetId, discoverParam, nullptr);
447 DeviceManagerImpl::GetInstance().UnbindTarget(str, targetId, discoverParam, nullptr);
448 DeviceManagerImpl::GetInstance().GetTrustedDeviceList(emptyStr, emptyStr, false, g_deviceList);
449 DeviceManagerImpl::GetInstance().UnRegisterDeviceManagerFaCallback(emptyStr);
450 DeviceManagerImpl::GetInstance().GetTrustedDeviceList(emptyStr, discoverParam, false, g_deviceList);
451 }
452 }
453 }
454
455 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)456 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
457 {
458 /* Run your code on data */
459 OHOS::DistributedHardware::AuthenticateDeviceFirstFuzzTest(data, size);
460 OHOS::DistributedHardware::AuthenticateDeviceSecondFuzzTest(data, size);
461 OHOS::DistributedHardware::AuthenticateDeviceThirdFuzzTest(data, size);
462 OHOS::DistributedHardware::AuthenticateDeviceFourthFuzzTest(data, size);
463 OHOS::DistributedHardware::AuthenticateDeviceFifthFuzzTest(data, size);
464 OHOS::DistributedHardware::AuthenticateDeviceSixthFuzzTest(data, size);
465 return 0;
466 }
467