1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "user_auth_service_fuzzer.h"
17
18 #include <cinttypes>
19 #include <cstddef>
20 #include <cstdint>
21
22 #include "parcel.h"
23
24 #include "iam_fuzz_test.h"
25 #include "iam_logger.h"
26 #include "user_auth_service.h"
27 #include "user_auth_common_defines.h"
28 #include "user_auth_event_listener_stub.h"
29 #include "dummy_iam_callback_interface.h"
30
31 #undef private
32
33 #ifdef LOG_LABEL
34 #undef LOG_LABEL
35 #endif
36 #define LOG_TAG "USER_AUTH_SA"
37
38 using namespace std;
39 using namespace OHOS::UserIam::Common;
40 using namespace OHOS::UserIam::UserAuth;
41
42 namespace OHOS {
43 namespace UserIam {
44 namespace UserAuth {
45 namespace {
46 class DummyUserAuthCallback : public UserAuthCallbackInterface {
47 public:
48 ~DummyUserAuthCallback() override = default;
49
OnAcquireInfo(int32_t module,int32_t acquireInfo,const Attributes & extraInfo)50 void OnAcquireInfo(int32_t module, int32_t acquireInfo, const Attributes &extraInfo) override
51 {
52 IAM_LOGI("start");
53 static_cast<void>(module);
54 static_cast<void>(acquireInfo);
55 static_cast<void>(extraInfo);
56 return;
57 }
58
OnResult(int32_t result,const Attributes & extraInfo)59 void OnResult(int32_t result, const Attributes &extraInfo) override
60 {
61 IAM_LOGI("start");
62 static_cast<void>(result);
63 static_cast<void>(extraInfo);
64 return;
65 }
66
AsObject()67 sptr<IRemoteObject> AsObject() override
68 {
69 sptr<IRemoteObject> tmp(nullptr);
70 return tmp;
71 }
72 };
73
74 class DummyGetExecutorPropertyCallback : public GetExecutorPropertyCallbackInterface {
75 public:
76 ~DummyGetExecutorPropertyCallback() override = default;
77
OnGetExecutorPropertyResult(int32_t result,const Attributes & attributes)78 void OnGetExecutorPropertyResult(int32_t result, const Attributes &attributes) override
79 {
80 IAM_LOGI("start");
81 return;
82 }
83
AsObject()84 sptr<IRemoteObject> AsObject() override
85 {
86 sptr<IRemoteObject> tmp(nullptr);
87 return tmp;
88 }
89 };
90
91 class DummySetExecutorPropertyCallback : public SetExecutorPropertyCallbackInterface {
92 public:
93 ~DummySetExecutorPropertyCallback() override = default;
94
OnSetExecutorPropertyResult(int32_t result)95 void OnSetExecutorPropertyResult(int32_t result) override
96 {
97 IAM_LOGI("start");
98 return;
99 }
100
AsObject()101 sptr<IRemoteObject> AsObject() override
102 {
103 sptr<IRemoteObject> tmp(nullptr);
104 return tmp;
105 }
106 };
107
108 class DummyWidgetCallback : public WidgetCallbackInterface {
109 public:
SendCommand(const std::string & cmdData)110 void SendCommand(const std::string &cmdData) override
111 {
112 IAM_LOGI("start");
113 }
114
AsObject()115 sptr<IRemoteObject> AsObject() override
116 {
117 sptr<IRemoteObject> tmp(nullptr);
118 return tmp;
119 }
120 };
121
122 class DummyAuthEventListener : public AuthEventListenerInterface {
123 public:
124 ~DummyAuthEventListener() override = default;
125
AsObject()126 sptr<IRemoteObject> AsObject() override
127 {
128 sptr<IRemoteObject> tmp(nullptr);
129 return tmp;
130 }
131
OnNotifyAuthSuccessEvent(int32_t userId,AuthType authType,int32_t callerType,std::string & callerName)132 void OnNotifyAuthSuccessEvent(int32_t userId, AuthType authType, int32_t callerType,
133 std::string &callerName) override
134 {
135 IAM_LOGI("notify: userId: %{public}d, authType: %{public}d, callerName: %{public}s,"
136 "callerType: %{public}d", userId, static_cast<int32_t>(authType), callerName.c_str(), callerType);
137 }
138 };
139
140 UserAuthService g_userAuthService;
141
FuzzGetEnrolledState(Parcel & parcel)142 void FuzzGetEnrolledState(Parcel &parcel)
143 {
144 IAM_LOGI("begin");
145 int32_t apiVersion = parcel.ReadInt32();
146 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
147 EnrolledState enrolledState = {};
148 g_userAuthService.GetEnrolledState(apiVersion, authType, enrolledState);
149 IAM_LOGI("end");
150 }
151
FuzzGetAvailableStatusOtherScene(Parcel & parcel)152 void FuzzGetAvailableStatusOtherScene(Parcel &parcel)
153 {
154 IAM_LOGI("begin");
155 int32_t apiVersion = 8;
156 int32_t pin = 1;
157 AuthType authType = static_cast<AuthType>(pin);
158 AuthTrustLevel authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32());
159 int32_t userId = parcel.ReadInt32();
160 g_userAuthService.GetAvailableStatus(apiVersion, userId, authType, authTrustLevel);
161 IAM_LOGI("end");
162 }
163
FuzzGetAvailableStatus(Parcel & parcel)164 void FuzzGetAvailableStatus(Parcel &parcel)
165 {
166 IAM_LOGI("begin");
167 int32_t apiVersion = parcel.ReadInt32();
168 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
169 AuthTrustLevel authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32());
170 int32_t userId = parcel.ReadInt32();
171 g_userAuthService.GetAvailableStatus(apiVersion, userId, authType, authTrustLevel);
172 FuzzGetAvailableStatusOtherScene(parcel);
173 IAM_LOGI("end");
174 }
175
FuzzGetProperty(Parcel & parcel)176 void FuzzGetProperty(Parcel &parcel)
177 {
178 IAM_LOGI("begin");
179 constexpr uint32_t maxDataLen = 50;
180 int32_t userId = parcel.ReadInt32();
181 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
182 std::vector<Attributes::AttributeKey> keys;
183 uint32_t keysLen = parcel.ReadUint32() % maxDataLen;
184 keys.reserve(keysLen);
185 for (uint32_t i = 0; i < keysLen; i++) {
186 keys.emplace_back(static_cast<Attributes::AttributeKey>(parcel.ReadInt32()));
187 }
188
189 sptr<GetExecutorPropertyCallbackInterface> callback(nullptr);
190 if (parcel.ReadBool()) {
191 callback = sptr<GetExecutorPropertyCallbackInterface>(new (std::nothrow) DummyGetExecutorPropertyCallback());
192 }
193 g_userAuthService.GetProperty(userId, authType, keys, callback);
194 IAM_LOGI("end");
195 }
196
FuzzSetProperty(Parcel & parcel)197 void FuzzSetProperty(Parcel &parcel)
198 {
199 IAM_LOGI("begin");
200 int32_t userId = parcel.ReadInt32();
201 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
202 vector<uint8_t> attributesRaw;
203 FillFuzzUint8Vector(parcel, attributesRaw);
204 Attributes attributes(attributesRaw);
205 sptr<SetExecutorPropertyCallbackInterface> callback(nullptr);
206 if (parcel.ReadBool()) {
207 callback = sptr<SetExecutorPropertyCallbackInterface>(new (nothrow) DummySetExecutorPropertyCallback());
208 }
209
210 g_userAuthService.SetProperty(userId, authType, attributes, callback);
211 IAM_LOGI("end");
212 }
213
FuzzAuth(Parcel & parcel)214 void FuzzAuth(Parcel &parcel)
215 {
216 IAM_LOGI("begin");
217 int32_t apiVersion = parcel.ReadInt32();
218 std::vector<uint8_t> challenge;
219 FillFuzzUint8Vector(parcel, challenge);
220 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
221 AuthTrustLevel authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32());
222 sptr<UserAuthCallbackInterface> callback(nullptr);
223 if (parcel.ReadBool()) {
224 callback = sptr<UserAuthCallbackInterface>(new (std::nothrow) DummyUserAuthCallback());
225 }
226 g_userAuthService.Auth(apiVersion, challenge, authType, authTrustLevel, callback);
227 IAM_LOGI("end");
228 }
229
FuzzAuthUser(Parcel & parcel)230 void FuzzAuthUser(Parcel &parcel)
231 {
232 IAM_LOGI("begin");
233 std::vector<uint8_t> challenge;
234 FillFuzzUint8Vector(parcel, challenge);
235 sptr<UserAuthCallbackInterface> callback(nullptr);
236 if (parcel.ReadBool()) {
237 callback = sptr<UserAuthCallbackInterface>(new (nothrow) DummyUserAuthCallback());
238 }
239 AuthParamInner param = {
240 .userId = parcel.ReadInt32(),
241 .challenge = challenge,
242 .authType = static_cast<AuthType>(parcel.ReadInt32()),
243 .authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32()),
244 };
245 std::optional<RemoteAuthParam> remoteAuthParam = std::nullopt;
246 g_userAuthService.AuthUser(param, remoteAuthParam, callback);
247 IAM_LOGI("end");
248 }
249
FuzzIdentify(Parcel & parcel)250 void FuzzIdentify(Parcel &parcel)
251 {
252 IAM_LOGI("begin");
253 std::vector<uint8_t> challenge;
254 FillFuzzUint8Vector(parcel, challenge);
255 AuthType authType = static_cast<AuthType>(parcel.ReadInt32());
256 sptr<UserAuthCallbackInterface> callback(nullptr);
257 if (parcel.ReadBool()) {
258 callback = sptr<UserAuthCallbackInterface>(new (nothrow) DummyUserAuthCallback());
259 }
260 g_userAuthService.Identify(challenge, authType, callback);
261 IAM_LOGI("end");
262 }
263
FuzzCancelAuthOrIdentify(Parcel & parcel)264 void FuzzCancelAuthOrIdentify(Parcel &parcel)
265 {
266 IAM_LOGI("begin");
267 uint64_t contextId = parcel.ReadUint64();
268 g_userAuthService.CancelAuthOrIdentify(contextId);
269 IAM_LOGI("end");
270 }
271
FuzzGetVersion(Parcel & parcel)272 void FuzzGetVersion(Parcel &parcel)
273 {
274 IAM_LOGI("begin");
275 int32_t version = -1;
276 g_userAuthService.GetVersion(version);
277 IAM_LOGI("end");
278 }
279
FuzzAuthWidget(Parcel & parcel)280 void FuzzAuthWidget(Parcel &parcel)
281 {
282 IAM_LOGI("begin");
283 int32_t apiVersion = parcel.ReadInt32();
284 AuthParamInner authParam;
285 WidgetParam widgetParam;
286 FillFuzzUint8Vector(parcel, authParam.challenge);
287 std::vector<int32_t> atList;
288 parcel.ReadInt32Vector(&atList);
289 for (auto at : atList) {
290 authParam.authTypes.push_back(static_cast<AuthType>(at));
291 }
292 authParam.authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32());
293 sptr<UserAuthCallbackInterface> callback(nullptr);
294 widgetParam.title = parcel.ReadString();
295 widgetParam.navigationButtonText = parcel.ReadString();
296 widgetParam.windowMode = static_cast<WindowModeType>(parcel.ReadInt32());
297 if (parcel.ReadBool()) {
298 callback = sptr<UserAuthCallbackInterface>(new (std::nothrow) DummyUserAuthCallback());
299 }
300 g_userAuthService.AuthWidget(apiVersion, authParam, widgetParam, callback);
301 IAM_LOGI("end");
302 }
303
FuzzNotice(Parcel & parcel)304 void FuzzNotice(Parcel &parcel)
305 {
306 IAM_LOGI("begin");
307 NoticeType noticeType = static_cast<NoticeType>(parcel.ReadInt32());
308 std::string eventData = parcel.ReadString();
309 g_userAuthService.Notice(noticeType, eventData);
310 IAM_LOGI("end");
311 }
312
FuzzRegisterWidgetCallback(Parcel & parcel)313 void FuzzRegisterWidgetCallback(Parcel &parcel)
314 {
315 IAM_LOGI("begin");
316 int32_t version = parcel.ReadInt32();
317 sptr<WidgetCallbackInterface> callback(nullptr);
318 if (parcel.ReadBool()) {
319 callback = sptr<WidgetCallbackInterface>(new (std::nothrow) DummyWidgetCallback());
320 }
321 g_userAuthService.RegisterWidgetCallback(version, callback);
322 IAM_LOGI("end");
323 }
324
FuzzRegistUserAuthSuccessEventListener(Parcel & parcel)325 void FuzzRegistUserAuthSuccessEventListener(Parcel &parcel)
326 {
327 IAM_LOGI("begin");
328 std::vector<int32_t> authType;
329 std::vector<AuthType> authTypeList;
330 parcel.ReadInt32Vector(&authType);
331 for (const auto &iter : authType) {
332 authTypeList.push_back(static_cast<AuthType>(iter));
333 }
334
335 sptr<AuthEventListenerInterface> callback(nullptr);
336 if (parcel.ReadBool()) {
337 callback = sptr<AuthEventListenerInterface>(new (std::nothrow) DummyAuthEventListener());
338 }
339
340 g_userAuthService.RegistUserAuthSuccessEventListener(authTypeList, callback);
341 g_userAuthService.UnRegistUserAuthSuccessEventListener(callback);
342 IAM_LOGI("end");
343 }
344
FuzzSetGlobalConfigParam(Parcel & parcel)345 void FuzzSetGlobalConfigParam(Parcel &parcel)
346 {
347 IAM_LOGI("start");
348 GlobalConfigParam param = {};
349 param.value.pinExpiredPeriod = parcel.ReadUint64();
350 param.type = static_cast<GlobalConfigType>(parcel.ReadInt32());
351 g_userAuthService.SetGlobalConfigParam(param);
352 IAM_LOGI("end");
353 }
354
FuzzPrepareRemoteAuth(Parcel & parcel)355 void FuzzPrepareRemoteAuth(Parcel &parcel)
356 {
357 IAM_LOGI("begin");
358 std::string networkId = parcel.ReadString();
359 sptr<UserAuthCallbackInterface> callback(nullptr);
360 if (parcel.ReadBool()) {
361 callback = sptr<UserAuthCallbackInterface>(new (nothrow) DummyUserAuthCallback());
362 }
363 g_userAuthService.PrepareRemoteAuth(networkId, callback);
364 IAM_LOGI("end");
365 }
366
FuzzGetAndUpateOsAccountVerifiedState(Parcel & parcel)367 void FuzzGetAndUpateOsAccountVerifiedState(Parcel &parcel)
368 {
369 IAM_LOGI("begin");
370 int32_t userId = parcel.ReadInt32();
371 g_userAuthService.GetAndUpateOsAccountVerifiedState(userId);
372 IAM_LOGI("end");
373 }
374
FuzzCheckValidSolution(Parcel & parcel)375 void FuzzCheckValidSolution(Parcel &parcel)
376 {
377 IAM_LOGI("begin");
378 int32_t userId = parcel.ReadInt32();
379 std::vector<uint8_t> challenge;
380 FillFuzzUint8Vector(parcel, challenge);
381 AuthParamInner authParam = {
382 .userId = parcel.ReadInt32(),
383 .challenge = challenge,
384 .authType = static_cast<AuthType>(parcel.ReadInt32()),
385 .authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32()),
386 };
387 WidgetParam widgetParam;
388 widgetParam.title = parcel.ReadString();
389 widgetParam.navigationButtonText = parcel.ReadString();
390 widgetParam.windowMode = static_cast<WindowModeType>(parcel.ReadInt32());
391 std::vector<int32_t> authType;
392 std::vector<AuthType> validType;
393 parcel.ReadInt32Vector(&authType);
394 for (const auto &iter : authType) {
395 validType.push_back(static_cast<AuthType>(iter));
396 }
397 g_userAuthService.CheckValidSolution(userId, authParam, widgetParam, validType);
398 IAM_LOGI("end");
399 }
400
401
FuzzCompleteRemoteAuthParam(Parcel & parcel)402 void FuzzCompleteRemoteAuthParam(Parcel &parcel)
403 {
404 IAM_LOGI("begin");
405 RemoteAuthParam remoteAuthParam = {};
406 std::string localNetworkId = "1234567890123456789012345678901234567890123456789012345678901234";
407 remoteAuthParam.verifierNetworkId = std::nullopt;
408 g_userAuthService.CompleteRemoteAuthParam(remoteAuthParam, localNetworkId);
409 remoteAuthParam.verifierNetworkId = "123";
410 remoteAuthParam.collectorNetworkId = "1234123456789012345678901234567890123456789012345678901234567890";
411 g_userAuthService.CompleteRemoteAuthParam(remoteAuthParam, localNetworkId);
412 remoteAuthParam.verifierNetworkId = localNetworkId;
413 g_userAuthService.CompleteRemoteAuthParam(remoteAuthParam, localNetworkId);
414 IAM_LOGI("end");
415 }
416
FuzzGetAuthContextCallback(Parcel & parcel)417 void FuzzGetAuthContextCallback(Parcel &parcel)
418 {
419 IAM_LOGI("begin");
420 int32_t apiVersion = parcel.ReadInt32();
421 AuthParamInner authParam = {};
422 WidgetParam widgetParam = {};
423 sptr<UserAuthCallbackInterface> callback = sptr<UserAuthCallbackInterface>(new (nothrow) DummyUserAuthCallback);
424 g_userAuthService.GetAuthContextCallback(apiVersion, authParam, widgetParam, callback);
425 authParam.authTypes = {PIN, FACE, FINGERPRINT};
426 ReuseUnlockResult reuseUnlockResult = {};
427 reuseUnlockResult.isReuse = true;
428 authParam.reuseUnlockResult = reuseUnlockResult;
429 g_userAuthService.GetAuthContextCallback(apiVersion, authParam, widgetParam, callback);
430 IAM_LOGI("end");
431 }
432
FuzzInsert2ContextPool(Parcel & parcel)433 void FuzzInsert2ContextPool(Parcel &parcel)
434 {
435 IAM_LOGI("begin");
436 ContextFactory::AuthWidgetContextPara para = {};
437 auto context = ContextFactory::CreateWidgetContext(para, nullptr);
438 g_userAuthService.Insert2ContextPool(context);
439 IAM_LOGI("end");
440 }
441
FuzzCheckAuthWidgetType(Parcel & parcel)442 void FuzzCheckAuthWidgetType(Parcel &parcel)
443 {
444 IAM_LOGI("begin");
445 std::vector<AuthType> authType = {PIN, FACE, FINGERPRINT};
446 g_userAuthService.CheckAuthWidgetType(authType);
447 authType = {PIN, FACE, FINGERPRINT, RECOVERY_KEY};
448 g_userAuthService.CheckAuthWidgetType(authType);
449 IAM_LOGI("end");
450 }
451
FuzzCheckSingeFaceOrFinger(Parcel & parcel)452 void FuzzCheckSingeFaceOrFinger(Parcel &parcel)
453 {
454 IAM_LOGI("begin");
455 std::vector<AuthType> authType = {PIN, FACE, FINGERPRINT};
456 g_userAuthService.CheckSingeFaceOrFinger(authType);
457 authType = {PIN};
458 g_userAuthService.CheckSingeFaceOrFinger(authType);
459 authType = {FACE};
460 g_userAuthService.CheckSingeFaceOrFinger(authType);
461 authType = {FINGERPRINT};
462 g_userAuthService.CheckSingeFaceOrFinger(authType);
463 IAM_LOGI("end");
464 }
465
FuzzAuthRemoteUser(Parcel & parcel)466 void FuzzAuthRemoteUser(Parcel &parcel)
467 {
468 IAM_LOGI("begin");
469 std::vector<uint8_t> challenge;
470 FillFuzzUint8Vector(parcel, challenge);
471 AuthParamInner authParam = {
472 .userId = INVALID_USER_ID,
473 .challenge = challenge,
474 .authType = static_cast<AuthType>(parcel.ReadInt32()),
475 .authTrustLevel = static_cast<AuthTrustLevel>(parcel.ReadInt32()),
476 };
477 Authentication::AuthenticationPara para = {};
478 RemoteAuthParam remoteAuthParam = {};
479 sptr<IamCallbackInterface> iamCallback = sptr<IamCallbackInterface>(new (nothrow) DummyIamCallbackInterface);
480 std::shared_ptr<ContextCallback> contextCallback = ContextCallback::NewInstance(iamCallback, TRACE_ADD_CREDENTIAL);
481 ResultCode failReason = SUCCESS;
482 g_userAuthService.AuthRemoteUser(authParam, para, remoteAuthParam, contextCallback, failReason);
483 authParam.authType = PIN;
484 g_userAuthService.AuthRemoteUser(authParam, para, remoteAuthParam, contextCallback, failReason);
485 IAM_LOGI("end");
486 }
487
FuzzFillGetPropertyValue(Parcel & parcel)488 void FuzzFillGetPropertyValue(Parcel &parcel)
489 {
490 IAM_LOGI("begin");
491 AuthType authType = PIN;
492 std::vector<Attributes::AttributeKey> keys = {Attributes::ATTR_NEXT_FAIL_LOCKOUT_DURATION};
493 Attributes *values = new Attributes();
494 g_userAuthService.FillGetPropertyValue(authType, keys, *values);
495 authType = FACE;
496 g_userAuthService.FillGetPropertyValue(authType, keys, *values);
497 IAM_LOGI("end");
498 }
499
FuzzFillGetPropertyKeys(Parcel & parcel)500 void FuzzFillGetPropertyKeys(Parcel &parcel)
501 {
502 IAM_LOGI("begin");
503 AuthType authType = PIN;
504 std::vector<Attributes::AttributeKey> keys = {Attributes::ATTR_NEXT_FAIL_LOCKOUT_DURATION};
505 std::vector<uint32_t> uint32Keys = {parcel.ReadInt32(), parcel.ReadInt32()};
506 g_userAuthService.FillGetPropertyKeys(authType, keys, uint32Keys);
507 authType = FACE;
508 g_userAuthService.FillGetPropertyKeys(authType, keys, uint32Keys);
509 IAM_LOGI("end");
510 }
511
FuzzStartWidgetContext(Parcel & parcel)512 void FuzzStartWidgetContext(Parcel &parcel)
513 {
514 IAM_LOGI("begin");
515 sptr<IamCallbackInterface> iamCallback = sptr<IamCallbackInterface>(new (nothrow) DummyIamCallbackInterface);
516 std::shared_ptr<ContextCallback> contextCallback = ContextCallback::NewInstance(iamCallback, TRACE_ADD_CREDENTIAL);
517 AuthParamInner authParam = {};
518 WidgetParam widgetParam = {};
519 std::vector<AuthType> validType = {PIN};
520 ContextFactory::AuthWidgetContextPara para;
521 g_userAuthService.StartWidgetContext(contextCallback, authParam, widgetParam, validType, para);
522 IAM_LOGI("end");
523 }
524
FuzzStartRemoteAuthInvokerContext(Parcel & parcel)525 void FuzzStartRemoteAuthInvokerContext(Parcel &parcel)
526 {
527 IAM_LOGI("begin");
528 AuthParamInner authParam = {};
529 RemoteAuthInvokerContextParam param = {};
530 sptr<IamCallbackInterface> iamCallback = sptr<IamCallbackInterface>(new (nothrow) DummyIamCallbackInterface);
531 std::shared_ptr<ContextCallback> contextCallback = ContextCallback::NewInstance(iamCallback, TRACE_ADD_CREDENTIAL);
532 g_userAuthService.StartRemoteAuthInvokerContext(authParam, param, contextCallback);
533 IAM_LOGI("end");
534 }
535
FuzzStartAuthContext(Parcel & parcel)536 void FuzzStartAuthContext(Parcel &parcel)
537 {
538 IAM_LOGI("begin");
539 int32_t apiVersion = parcel.ReadInt32();
540 Authentication::AuthenticationPara para;
541 sptr<IamCallbackInterface> iamCallback = sptr<IamCallbackInterface>(new (nothrow) DummyIamCallbackInterface);
542 std::shared_ptr<ContextCallback> contextCallback = ContextCallback::NewInstance(iamCallback, TRACE_ADD_CREDENTIAL);
543 g_userAuthService.StartAuthContext(apiVersion, para, contextCallback);
544 IAM_LOGI("end");
545 }
546
547 using FuzzFunc = decltype(FuzzGetAvailableStatus);
548 FuzzFunc *g_fuzzFuncs[] = {
549 FuzzGetEnrolledState,
550 FuzzGetAvailableStatus,
551 FuzzGetProperty,
552 FuzzSetProperty,
553 FuzzAuth,
554 FuzzAuthUser,
555 FuzzIdentify,
556 FuzzCancelAuthOrIdentify,
557 FuzzGetVersion,
558 FuzzAuthWidget,
559 FuzzNotice,
560 FuzzRegisterWidgetCallback,
561 FuzzRegistUserAuthSuccessEventListener,
562 FuzzSetGlobalConfigParam,
563 FuzzPrepareRemoteAuth,
564 FuzzGetAndUpateOsAccountVerifiedState,
565 FuzzCheckValidSolution,
566 FuzzCompleteRemoteAuthParam,
567 FuzzGetAuthContextCallback,
568 FuzzInsert2ContextPool,
569 FuzzCheckAuthWidgetType,
570 FuzzCheckSingeFaceOrFinger,
571 FuzzAuthRemoteUser,
572 FuzzFillGetPropertyValue,
573 FuzzFillGetPropertyKeys,
574 FuzzStartWidgetContext,
575 FuzzStartRemoteAuthInvokerContext,
576 FuzzStartAuthContext,
577 };
578
UserAuthFuzzTest(const uint8_t * data,size_t size)579 void UserAuthFuzzTest(const uint8_t *data, size_t size)
580 {
581 Parcel parcel;
582 parcel.WriteBuffer(data, size);
583 parcel.RewindRead(0);
584 uint32_t index = parcel.ReadUint32() % (sizeof(g_fuzzFuncs)) / sizeof(FuzzFunc *);
585 auto fuzzFunc = g_fuzzFuncs[index];
586 fuzzFunc(parcel);
587 return;
588 }
589 } // namespace
590 } // namespace UserAuth
591 } // namespace UserIam
592 } // namespace OHOS
593
594 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)595 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
596 {
597 OHOS::UserIam::UserAuth::UserAuthFuzzTest(data, size);
598 return 0;
599 }
600