1 /*
2 * Copyright (c) 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 #include <fuzzer/FuzzedDataProvider.h>
16 #include <vector>
17
18 #include "auth_manager_fuzzer.h"
19
20 #include "auth_manager.h"
21 #include "deviceprofile_connector.h"
22 #include "device_manager_service_listener.h"
23 #include "dm_anonymous.h"
24 #include "dm_auth_context.h"
25 #include "dm_auth_manager_base.h"
26 #include "auth_manager.h"
27 #include "dm_auth_state_machine.h"
28 #include "dm_constants.h"
29 #include "dm_crypto.h"
30 #include "dm_log.h"
31
32
33 namespace OHOS {
34 namespace DistributedHardware {
35 namespace {
36 std::shared_ptr<DmAuthMessageProcessor> dmAuthMessageProcessor_ = std::make_shared<DmAuthMessageProcessor>();
37 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
38 std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
39 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
40 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
41 std::shared_ptr<AuthManager> authManager = std::make_shared<AuthSrcManager>(softbusConnector,
42 hiChainConnector, listener, hiChainAuthConnector);
43 std::shared_ptr<DmAuthContext> context_ = authManager->GetAuthContext();
44 std::shared_ptr<AuthManager> authSinkManager = std::make_shared<AuthSinkManager>(softbusConnector, hiChainConnector,
45 listener, hiChainAuthConnector);
46 }
47
ConvertSrcVersionFuzzTest(FuzzedDataProvider & fdp)48 void ConvertSrcVersionFuzzTest(FuzzedDataProvider &fdp)
49 {
50 std::string version = fdp.ConsumeRandomLengthString();
51 std::string edition = fdp.ConsumeRandomLengthString();
52 CleanNotifyCallback cleanNotifyCallback;
53 authManager->RegisterCleanNotifyCallback(cleanNotifyCallback);
54 authManager->SetAuthContext(context_);
55 authManager->GetAuthContext();
56 authManager->GeneratePincode();
57 authManager->ConvertSrcVersion(version, edition);
58 }
59
RegisterUiStateCallbackFuzzTest(FuzzedDataProvider & fdp)60 void RegisterUiStateCallbackFuzzTest(FuzzedDataProvider &fdp)
61 {
62 std::string pkgName = fdp.ConsumeRandomLengthString();
63 authManager->RegisterUiStateCallback(pkgName);
64 }
65
UnRegisterUiStateCallbackFuzzTest(FuzzedDataProvider & fdp)66 void UnRegisterUiStateCallbackFuzzTest(FuzzedDataProvider &fdp)
67 {
68 std::string pkgName = fdp.ConsumeRandomLengthString();
69 authManager->UnRegisterUiStateCallback(pkgName);
70 }
71
UnAuthenticateDeviceFuzzTest(FuzzedDataProvider & fdp)72 void UnAuthenticateDeviceFuzzTest(FuzzedDataProvider &fdp)
73 {
74 std::string pkgName = fdp.ConsumeRandomLengthString();
75 std::string udid = fdp.ConsumeRandomLengthString();
76 int32_t bindLevel = fdp.ConsumeIntegral<int32_t>();
77 authManager->UnAuthenticateDevice(pkgName, udid, bindLevel);
78 }
79
ImportAuthCodeFuzzTest(FuzzedDataProvider & fdp)80 void ImportAuthCodeFuzzTest(FuzzedDataProvider &fdp)
81 {
82 std::string pkgName = fdp.ConsumeRandomLengthString();
83 std::string authCode = fdp.ConsumeRandomLengthString();
84 authManager->ImportAuthCode(pkgName, authCode);
85 }
86
UnBindDeviceFuzzTest(FuzzedDataProvider & fdp)87 void UnBindDeviceFuzzTest(FuzzedDataProvider &fdp)
88 {
89 std::string pkgName = fdp.ConsumeRandomLengthString();
90 int32_t bindLevel = fdp.ConsumeIntegral<int32_t>();
91 std::string udid = fdp.ConsumeRandomLengthString();
92 std::string extra = fdp.ConsumeRandomLengthString();
93 authManager->UnBindDevice(pkgName, udid, bindLevel, extra);
94 }
95
StopAuthenticateDeviceFuzzTest(FuzzedDataProvider & fdp)96 void StopAuthenticateDeviceFuzzTest(FuzzedDataProvider &fdp)
97 {
98 std::string pkgName = fdp.ConsumeRandomLengthString();
99 authManager->StopAuthenticateDevice(pkgName);
100 authManager->OnScreenLocked();
101 }
102
HandleDeviceNotTrustFuzzTest(FuzzedDataProvider & fdp)103 void HandleDeviceNotTrustFuzzTest(FuzzedDataProvider &fdp)
104 {
105 std::string udid = fdp.ConsumeRandomLengthString();
106 authManager->HandleDeviceNotTrust(udid);
107 }
108
RegisterAuthenticationTypeFuzzTest(FuzzedDataProvider & fdp)109 void RegisterAuthenticationTypeFuzzTest(FuzzedDataProvider &fdp)
110 {
111 int32_t authenticationType = fdp.ConsumeIntegral<int32_t>();
112 authManager->RegisterAuthenticationType(authenticationType);
113 authManager->GetReason();
114 }
115
AuthDeviceSessionKeyFuzzTest(FuzzedDataProvider & fdp)116 void AuthDeviceSessionKeyFuzzTest(FuzzedDataProvider &fdp)
117 {
118 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
119 uint8_t sessionKey = fdp.ConsumeIntegral<uint8_t>();
120 uint32_t sessionKeyLen = fdp.ConsumeIntegral<uint32_t>();
121 authManager->AuthDeviceSessionKey(requestId, &sessionKey, sessionKeyLen);
122 }
123
AuthDeviceRequestFuzzTest(FuzzedDataProvider & fdp)124 void AuthDeviceRequestFuzzTest(FuzzedDataProvider &fdp)
125 {
126 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
127 int operationCode = fdp.ConsumeIntegral<int>();
128 const char* reqParams = fdp.ConsumeRandomLengthString().c_str();
129 char *ret = authManager->AuthDeviceRequest(requestId, operationCode, reqParams);
130 if (ret != nullptr) {
131 free(ret);
132 ret = nullptr;
133 }
134 }
135
SetAuthTypeFuzzTest(FuzzedDataProvider & fdp)136 void SetAuthTypeFuzzTest(FuzzedDataProvider &fdp)
137 {
138 int32_t authType = fdp.ConsumeIntegral<int32_t>();
139 authManager->SetAuthType(authType);
140 }
141
IsAuthTypeSupportedFuzzTest(FuzzedDataProvider & fdp)142 void IsAuthTypeSupportedFuzzTest(FuzzedDataProvider &fdp)
143 {
144 int32_t authType = fdp.ConsumeIntegral<int32_t>();
145 authManager->IsAuthTypeSupported(authType);
146 }
147
CheckAuthParamVaildFuzzTest(FuzzedDataProvider & fdp)148 void CheckAuthParamVaildFuzzTest(FuzzedDataProvider &fdp)
149 {
150 std::string pkgName = fdp.ConsumeRandomLengthString();
151 std::string deviceId = fdp.ConsumeRandomLengthString();
152 std::string extra = fdp.ConsumeRandomLengthString();
153 int32_t authType = fdp.ConsumeIntegral<int32_t>();
154 authManager->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
155 authType = 1;
156 authManager->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
157 }
158
ParseHmlInfoInJsonObjectFuzzTest(FuzzedDataProvider & fdp)159 void ParseHmlInfoInJsonObjectFuzzTest(FuzzedDataProvider &fdp)
160 {
161 JsonObject jsonObject;
162 jsonObject[PARAM_KEY_CONN_SESSIONTYPE] = fdp.ConsumeRandomLengthString();
163 jsonObject[PARAM_KEY_HML_ENABLE_160M] = fdp.ConsumeBool();
164 jsonObject[PARAM_KEY_HML_ACTIONID] = fdp.ConsumeRandomLengthString();
165 authManager->ParseHmlInfoInJsonObject(jsonObject);
166 }
167
ParseJsonObjectFuzzTest(FuzzedDataProvider & fdp)168 void ParseJsonObjectFuzzTest(FuzzedDataProvider &fdp)
169 {
170 JsonObject jsonObject;
171 jsonObject[APP_OPERATION_KEY] = fdp.ConsumeRandomLengthString();
172 jsonObject[CUSTOM_DESCRIPTION_KEY] = fdp.ConsumeRandomLengthString();
173 jsonObject[TAG_APP_THUMBNAIL2] = fdp.ConsumeRandomLengthString();
174 jsonObject[PARAM_CLOSE_SESSION_DELAY_SECONDS] = fdp.ConsumeRandomLengthString();
175 jsonObject[TAG_PEER_PKG_NAME] = fdp.ConsumeRandomLengthString();
176 jsonObject[DM_BUSINESS_ID] = fdp.ConsumeRandomLengthString();
177 authManager->ParseJsonObject(jsonObject);
178 }
179
GetBindLevelFuzzTest(FuzzedDataProvider & fdp)180 void GetBindLevelFuzzTest(FuzzedDataProvider &fdp)
181 {
182 int32_t bindLevel = fdp.ConsumeIntegral<int32_t>();
183 authManager->GetBindLevel(bindLevel);
184 }
185
GetAuthParamFuzzTest(FuzzedDataProvider & fdp)186 void GetAuthParamFuzzTest(FuzzedDataProvider &fdp)
187 {
188 int32_t authType = fdp.ConsumeIntegral<int32_t>();
189 std::string pkgName = fdp.ConsumeRandomLengthString();
190 std::string deviceId = fdp.ConsumeRandomLengthString();
191 std::string extra = fdp.ConsumeRandomLengthString();
192 authManager->GetAuthParam(pkgName, authType, deviceId, extra);
193 JsonObject jsonObject;
194 jsonObject[TAG_BIND_LEVEL] = fdp.ConsumeIntegral<int32_t>();
195 extra = jsonObject.Dump();
196 authManager->GetAuthParam(pkgName, authType, deviceId, extra);
197 }
198
InitAuthStateFuzzTest(FuzzedDataProvider & fdp)199 void InitAuthStateFuzzTest(FuzzedDataProvider &fdp)
200 {
201 int32_t authType = fdp.ConsumeIntegral<int32_t>();
202 std::string pkgName = fdp.ConsumeRandomLengthString();
203 std::string deviceId = fdp.ConsumeRandomLengthString();
204 std::string extra = fdp.ConsumeRandomLengthString();
205 authManager->InitAuthState(pkgName, authType, deviceId, extra);
206 }
207
AuthenticateDeviceFuzzTest(FuzzedDataProvider & fdp)208 void AuthenticateDeviceFuzzTest(FuzzedDataProvider &fdp)
209 {
210 int32_t authType = fdp.ConsumeIntegral<int32_t>();
211 std::string pkgName = fdp.ConsumeRandomLengthString();
212 std::string deviceId = fdp.ConsumeRandomLengthString();
213 std::string extra = fdp.ConsumeRandomLengthString();
214 authManager->AuthenticateDevice(pkgName, authType, deviceId, extra);
215 }
216
AuthDeviceErrorFuzzTest(FuzzedDataProvider & fdp)217 void AuthDeviceErrorFuzzTest(FuzzedDataProvider &fdp)
218 {
219 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
220 int32_t errorCode = fdp.ConsumeIntegral<int32_t>();
221 authManager->AuthDeviceError(requestId, errorCode);
222 authSinkManager->AuthDeviceError(requestId, errorCode);
223 requestId = context_->requestId;
224 authManager->AuthDeviceError(requestId, errorCode);
225 }
226
AuthDeviceFinishFuzzTest(FuzzedDataProvider & fdp)227 void AuthDeviceFinishFuzzTest(FuzzedDataProvider &fdp)
228 {
229 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
230 authManager->AuthDeviceFinish(requestId);
231 authSinkManager->AuthDeviceFinish(requestId);
232 }
233
GetPinCodeFuzzTest(FuzzedDataProvider & fdp)234 void GetPinCodeFuzzTest(FuzzedDataProvider &fdp)
235 {
236 std::string code = fdp.ConsumeRandomLengthString();
237 authManager->GetPinCode(code);
238 }
239
GetAuthCodeAndPkgNameFuzzTest(FuzzedDataProvider & fdp)240 void GetAuthCodeAndPkgNameFuzzTest(FuzzedDataProvider &fdp)
241 {
242 std::string pkgName = fdp.ConsumeRandomLengthString();
243 std::string authCode = fdp.ConsumeRandomLengthString();
244 authManager->GetAuthCodeAndPkgName(pkgName, authCode);
245 }
246
IsAuthCodeReadyFuzzTest(FuzzedDataProvider & fdp)247 void IsAuthCodeReadyFuzzTest(FuzzedDataProvider &fdp)
248 {
249 std::string pkgName = fdp.ConsumeRandomLengthString();
250 authManager->IsAuthCodeReady(pkgName);
251 }
252
ParseUltrasonicSideFuzzTest(FuzzedDataProvider & fdp)253 void ParseUltrasonicSideFuzzTest(FuzzedDataProvider &fdp)
254 {
255 JsonObject jsonObject;
256 jsonObject[TAG_ULTRASONIC_SIDE] = fdp.ConsumeRandomLengthString();
257 authManager->ParseUltrasonicSide(jsonObject);
258 }
259
BindTargetFuzzTest(FuzzedDataProvider & fdp)260 void BindTargetFuzzTest(FuzzedDataProvider &fdp)
261 {
262 std::string pkgName = fdp.ConsumeRandomLengthString();
263 PeerTargetId targetId;
264 std::map<std::string, std::string> bindParam;
265 int sessionId = fdp.ConsumeIntegral<int>();
266 uint64_t logicalSessionId = fdp.ConsumeIntegral<uint64_t>();
267 authManager->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
268 bindParam[PARAM_KEY_AUTH_TYPE] = "1";
269 authManager->BindTarget(pkgName, targetId, bindParam, sessionId, logicalSessionId);
270 authManager->GetBindTargetParams(pkgName, targetId, bindParam);
271 authManager->SetBindTargetParams(targetId);
272 }
273
OnSessionClosedFuzzTest(FuzzedDataProvider & fdp)274 void OnSessionClosedFuzzTest(FuzzedDataProvider &fdp)
275 {
276 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
277 authSinkManager->OnSessionClosed(sessionId);
278 }
279
OnDataReceivedFuzzTest(FuzzedDataProvider & fdp)280 void OnDataReceivedFuzzTest(FuzzedDataProvider &fdp)
281 {
282 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
283 std::string message = fdp.ConsumeRandomLengthString();
284 authSinkManager->OnDataReceived(sessionId, message);
285 authSinkManager->GetIsCryptoSupport();
286 }
287
GetRemoteDeviceIdFuzzTest(FuzzedDataProvider & fdp)288 void GetRemoteDeviceIdFuzzTest(FuzzedDataProvider &fdp)
289 {
290 std::string deviceId = fdp.ConsumeRandomLengthString();
291 authManager->GetRemoteDeviceId(deviceId);
292 }
293
OnUserOperationFuzzTest(FuzzedDataProvider & fdp)294 void OnUserOperationFuzzTest(FuzzedDataProvider &fdp)
295 {
296 int32_t action = fdp.ConsumeIntegral<int32_t>();
297 std::string params = fdp.ConsumeRandomLengthString();
298 authSinkManager->OnUserOperation(action, params);
299 action = USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT;
300 authSinkManager->OnUserOperation(action, params);
301 action = USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY;
302 authSinkManager->OnUserOperation(action, params);
303 }
304
OnSessionOpenedFuzzTest(FuzzedDataProvider & fdp)305 void OnSessionOpenedFuzzTest(FuzzedDataProvider &fdp)
306 {
307 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
308 int32_t sessionSide = fdp.ConsumeIntegral<int32_t>();
309 int32_t result = fdp.ConsumeIntegral<int32_t>();
310 authManager->OnSessionOpened(sessionId, sessionSide, result);
311 authSinkManager->OnSessionOpened(sessionId, sessionSide, result);
312 }
313
OnSrcSessionClosedFuzzTest(FuzzedDataProvider & fdp)314 void OnSrcSessionClosedFuzzTest(FuzzedDataProvider &fdp)
315 {
316 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
317 authManager->OnSessionClosed(sessionId);
318 }
319
OnSrcDataReceivedFuzzTest(FuzzedDataProvider & fdp)320 void OnSrcDataReceivedFuzzTest(FuzzedDataProvider &fdp)
321 {
322 int32_t sessionId = fdp.ConsumeIntegral<int32_t>();
323 std::string message = fdp.ConsumeRandomLengthString();
324 authManager->OnDataReceived(sessionId, message);
325 authManager->OnSessionDisable();
326 authManager->GetIsCryptoSupport();
327 }
328
OnSrcUserOperationFuzzTest(FuzzedDataProvider & fdp)329 void OnSrcUserOperationFuzzTest(FuzzedDataProvider &fdp)
330 {
331 int32_t action = fdp.ConsumeIntegral<int32_t>();
332 std::string params = fdp.ConsumeRandomLengthString();
333 authManager->OnUserOperation(action, params);
334 action = USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT;
335 authManager->OnUserOperation(action, params);
336 action = USER_OPERATION_TYPE_DONE_PINCODE_INPUT;
337 authManager->OnUserOperation(action, params);
338 }
339
AuthDeviceTransmitFuzzTest(FuzzedDataProvider & fdp)340 void AuthDeviceTransmitFuzzTest(FuzzedDataProvider &fdp)
341 {
342 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
343 uint8_t data = fdp.ConsumeIntegral<uint8_t>();
344 uint32_t dataLen = fdp.ConsumeIntegral<uint32_t>();
345 authManager->AuthDeviceTransmit(requestId, &data, dataLen);
346 }
347
AuthSinkDeviceTransmitFuzzTest(FuzzedDataProvider & fdp)348 void AuthSinkDeviceTransmitFuzzTest(FuzzedDataProvider &fdp)
349 {
350 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
351 uint8_t data = fdp.ConsumeIntegral<uint8_t>();
352 uint32_t dataLen = fdp.ConsumeIntegral<uint32_t>();
353 authSinkManager->AuthDeviceTransmit(requestId, &data, dataLen);
354 }
355
AuthSinkDeviceSessionKeyFuzzTest(FuzzedDataProvider & fdp)356 void AuthSinkDeviceSessionKeyFuzzTest(FuzzedDataProvider &fdp)
357 {
358 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
359 uint8_t sessionKey = fdp.ConsumeIntegral<uint8_t>();
360 uint32_t sessionKeyLen = fdp.ConsumeIntegral<uint32_t>();
361 authSinkManager->AuthDeviceSessionKey(requestId, &sessionKey, sessionKeyLen);
362 }
363
AuthSinkDeviceRequestFuzzTest(FuzzedDataProvider & fdp)364 void AuthSinkDeviceRequestFuzzTest(FuzzedDataProvider &fdp)
365 {
366 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
367 int operationCode = fdp.ConsumeIntegral<int>();
368 const char* reqParams = fdp.ConsumeRandomLengthString().c_str();
369 char *ret = authSinkManager->AuthDeviceRequest(requestId, operationCode, reqParams);
370 if (ret != nullptr) {
371 free(ret);
372 ret = nullptr;
373 }
374 authManager->DeleteTimer();
375 authManager->GetBindCallerInfo();
376 }
377
HandleBusinessEventsFuzzTest(FuzzedDataProvider & fdp)378 void HandleBusinessEventsFuzzTest(FuzzedDataProvider &fdp)
379 {
380 std::string businessId = fdp.ConsumeRandomLengthString();
381 int action = fdp.ConsumeIntegral<int>();
382 authManager->HandleBusinessEvents(businessId, action);
383 authManager->ClearSoftbusSessionCallback();
384 authManager->PrepareSoftbusSessionCallback();
385 }
386
ParseProxyJsonObjectFuzzTest(FuzzedDataProvider & fdp)387 void ParseProxyJsonObjectFuzzTest(FuzzedDataProvider &fdp)
388 {
389 JsonObject jsonObject;
390 jsonObject[PARAM_KEY_IS_PROXY_BIND] = fdp.ConsumeRandomLengthString();
391 jsonObject[PARAM_KEY_IS_CALLING_PROXY_AS_SUBJECT] = fdp.ConsumeRandomLengthString();
392 jsonObject[PARAM_KEY_SUBJECT_PROXYED_SUBJECTS] = fdp.ConsumeRandomLengthString();
393 authManager->ParseProxyJsonObject(jsonObject);
394 }
395
GetBindLevelByBundleNameFuzzTest(FuzzedDataProvider & fdp)396 void GetBindLevelByBundleNameFuzzTest(FuzzedDataProvider &fdp)
397 {
398 std::string bundleName = fdp.ConsumeRandomLengthString();
399 int32_t requestId = fdp.ConsumeIntegral<int32_t>();
400 int32_t bindLevel = 0;
401 authManager->GetBindLevelByBundleName(bundleName, requestId, bindLevel);
402 }
403
AuthManagerFuzzTest(const uint8_t * data,size_t size)404 void AuthManagerFuzzTest(const uint8_t* data, size_t size)
405 {
406 if ((data == nullptr) || (size == 0)) {
407 return;
408 }
409 FuzzedDataProvider fdp(data, size);
410 ConvertSrcVersionFuzzTest(fdp);
411 RegisterUiStateCallbackFuzzTest(fdp);
412 UnRegisterUiStateCallbackFuzzTest(fdp);
413 UnAuthenticateDeviceFuzzTest(fdp);
414 ImportAuthCodeFuzzTest(fdp);
415 UnBindDeviceFuzzTest(fdp);
416 StopAuthenticateDeviceFuzzTest(fdp);
417 HandleDeviceNotTrustFuzzTest(fdp);
418 RegisterAuthenticationTypeFuzzTest(fdp);
419 AuthDeviceSessionKeyFuzzTest(fdp);
420 AuthDeviceRequestFuzzTest(fdp);
421 SetAuthTypeFuzzTest(fdp);
422 IsAuthTypeSupportedFuzzTest(fdp);
423 ParseHmlInfoInJsonObjectFuzzTest(fdp);
424 CheckAuthParamVaildFuzzTest(fdp);
425 ParseJsonObjectFuzzTest(fdp);
426 GetBindLevelFuzzTest(fdp);
427 GetAuthParamFuzzTest(fdp);
428 InitAuthStateFuzzTest(fdp);
429 AuthDeviceErrorFuzzTest(fdp);
430 AuthDeviceFinishFuzzTest(fdp);
431 GetAuthCodeAndPkgNameFuzzTest(fdp);
432 GetPinCodeFuzzTest(fdp);
433 AuthenticateDeviceFuzzTest(fdp);
434 BindTargetFuzzTest(fdp);
435 ParseUltrasonicSideFuzzTest(fdp);
436 IsAuthCodeReadyFuzzTest(fdp);
437 AuthSinkDeviceSessionKeyFuzzTest(fdp);
438 OnSessionClosedFuzzTest(fdp);
439 OnDataReceivedFuzzTest(fdp);
440 GetRemoteDeviceIdFuzzTest(fdp);
441 OnUserOperationFuzzTest(fdp);
442 OnSessionOpenedFuzzTest(fdp);
443 OnSrcSessionClosedFuzzTest(fdp);
444 OnSrcUserOperationFuzzTest(fdp);
445 AuthDeviceTransmitFuzzTest(fdp);
446 AuthSinkDeviceTransmitFuzzTest(fdp);
447 AuthSinkDeviceSessionKeyFuzzTest(fdp);
448 AuthSinkDeviceRequestFuzzTest(fdp);
449 HandleBusinessEventsFuzzTest(fdp);
450 ParseProxyJsonObjectFuzzTest(fdp);
451 GetBindLevelByBundleNameFuzzTest(fdp);
452 }
453 }
454 }
455
456 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)457 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
458 {
459 /* Run your code on data */
460 OHOS::DistributedHardware::AuthManagerFuzzTest(data, size);
461 return 0;
462 }
463