1 /*
2 * Copyright (C) 2022 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_interface_service_test.h"
17
18 #include <memory>
19
20 #include "iam_ptr.h"
21 #include "securec.h"
22
23 #include "executor_message.h"
24 #include "user_auth_hdi.h"
25 #include "user_sign_centre.h"
26 #include "signature_operation.h"
27
28 namespace OHOS {
29 namespace HDI {
30 namespace UserAuth {
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace {
35 uint64_t g_pinIndex = 0;
36 uint64_t g_faceIndex = 0;
37 uint64_t g_fingerprintIndex = 0;
38 } // namespace
39
SetUpTestCase()40 void UserAuthInterfaceServiceTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void UserAuthInterfaceServiceTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void UserAuthInterfaceServiceTest::SetUp()
49 {
50 }
51
TearDown()52 void UserAuthInterfaceServiceTest::TearDown()
53 {
54 }
55
56 struct EnrollResultTest {
57 int32_t result;
58 uint64_t credentialId;
59 };
60
61 struct AuthResultTest {
62 int32_t result;
63 std::vector<uint8_t> token;
64 };
65
DoOnceExecutorRegister(const std::shared_ptr<UserAuthInterfaceService> & service,AuthType authType,uint64_t & index)66 int32_t DoOnceExecutorRegister(const std::shared_ptr<UserAuthInterfaceService> &service, AuthType authType,
67 uint64_t &index)
68 {
69 ExecutorRegisterInfo info = {};
70 info.authType = authType;
71 info.executorRole = ExecutorRole::ALL_IN_ONE;
72 info.esl = ExecutorSecureLevel::ESL0;
73 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
74 std::vector<uint8_t> publicKey;
75 std::vector<uint64_t> templateIds;
76
77 return service->AddExecutor(info, index, publicKey, templateIds);
78 }
79
RegisterAllExecutor(const std::shared_ptr<UserAuthInterfaceService> & service)80 void RegisterAllExecutor(const std::shared_ptr<UserAuthInterfaceService> &service)
81 {
82 EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::PIN, g_pinIndex), 0);
83 EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::FACE, g_faceIndex), 0);
84 EXPECT_EQ(DoOnceExecutorRegister(service, AuthType::FINGERPRINT, g_fingerprintIndex), 0);
85 }
86
DeleteAllExecutor(const std::shared_ptr<UserAuthInterfaceService> & service)87 void DeleteAllExecutor(const std::shared_ptr<UserAuthInterfaceService> &service)
88 {
89 EXPECT_EQ(service->DeleteExecutor(g_pinIndex), 0);
90 EXPECT_EQ(service->DeleteExecutor(g_faceIndex), 0);
91 EXPECT_EQ(service->DeleteExecutor(g_fingerprintIndex), 0);
92 }
93
DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,const std::vector<uint8_t> & authToken,EnrollResultTest & enrollResultTest)94 void DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
95 const std::vector<uint8_t> &authToken, EnrollResultTest &enrollResultTest)
96 {
97 EnrollParam enrollParam = {};
98 enrollParam.authType = authType;
99 ScheduleInfo scheduleInfo = {};
100 EXPECT_EQ(service->BeginEnrollment(userId, authToken, enrollParam, scheduleInfo), 0);
101
102 EnrollResultInfo enrolledResultInfo = {};
103 std::vector<uint8_t> enrollScheduleResult;
104 TlvRequiredPara para = {};
105 para.result = 0;
106 para.scheduleId = scheduleInfo.scheduleId;
107 para.subType = 10000;
108 para.templateId = 20;
109 para.remainAttempts = 5;
110 EXPECT_EQ(GetExecutorResultTlv(para, enrollScheduleResult), 0);
111
112 enrollResultTest.result = service->UpdateEnrollmentResult(userId, enrollScheduleResult, enrolledResultInfo);
113 enrollResultTest.credentialId = enrolledResultInfo.credentialId;
114 EXPECT_EQ(enrollResultTest.result, 0);
115 }
116
DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,std::vector<uint8_t> & challenge,AuthResultTest & authResultTest)117 void DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
118 std::vector<uint8_t> &challenge, AuthResultTest &authResultTest)
119 {
120 uint64_t contextId = 636548;
121 AuthSolution authParam = {};
122 authParam.userId = userId;
123 authParam.authTrustLevel = 10000;
124 authParam.authType = authType;
125 authParam.challenge = challenge;
126 std::vector<ScheduleInfo> scheduleInfos;
127 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
128 EXPECT_TRUE(!scheduleInfos.empty());
129
130 std::vector<uint8_t> authScheduleResult;
131 TlvRequiredPara para = {};
132 para.result = 0;
133 para.scheduleId = scheduleInfos[0].scheduleId;
134 para.subType = 10000;
135 para.templateId = 20;
136 para.remainAttempts = 5;
137 EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
138 AuthResultInfo authResultInfo = {};
139
140 authResultTest.result = service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo);
141 EXPECT_EQ(authResultTest.result, 0);
142 authResultTest.token = authResultInfo.token;
143 }
144
145 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_001, TestSize.Level0)
146 {
147 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
148 EXPECT_NE(service, nullptr);
149 int32_t userId = 1245;
150 std::vector<uint8_t> challenge;
151 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
152 EXPECT_EQ(challenge.size(), 32);
153 EXPECT_EQ(service->CloseSession(userId), 0);
154 }
155
156 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_002, TestSize.Level0)
157 {
158 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
159 EXPECT_NE(service, nullptr);
160
161 int32_t userId1 = 1245;
162 std::vector<uint8_t> challenge1;
163 EXPECT_EQ(service->OpenSession(userId1, challenge1), 0);
164 EXPECT_EQ(challenge1.size(), 32);
165
166 int32_t userId2 = 2245;
167 std::vector<uint8_t> challenge2;
168 EXPECT_EQ(service->OpenSession(userId2, challenge2), 0);
169 EXPECT_EQ(challenge2.size(), 32);
170
171 EXPECT_EQ(service->CloseSession(userId1), 0);
172 EXPECT_EQ(service->CloseSession(userId2), 2);
173 }
174
175 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_001, TestSize.Level0)
176 {
177 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
178 EXPECT_NE(service, nullptr);
179
180 ExecutorRegisterInfo info = {};
181 uint64_t index = 0;
182 std::vector<uint8_t> publicKey;
183 std::vector<uint64_t> templateIds;
184 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 8);
185 }
186
187 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_002, TestSize.Level0)
188 {
189 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
190 EXPECT_NE(service, nullptr);
191
192 EXPECT_EQ(service->Init(), 0);
193
194 ExecutorRegisterInfo info = {};
195 info.authType = AuthType::FACE;
196 info.publicKey.resize(32);
197 uint64_t index = 0;
198 std::vector<uint8_t> publicKey;
199 std::vector<uint64_t> templateIds;
200
201 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
202 EXPECT_NE(index, 0);
203 EXPECT_TRUE(!publicKey.empty());
204
205 EXPECT_EQ(service->DeleteExecutor(index), 0);
206 }
207
208 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_003, TestSize.Level0)
209 {
210 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
211 EXPECT_NE(service, nullptr);
212
213 EXPECT_EQ(service->Init(), 0);
214
215 ExecutorRegisterInfo info = {};
216 info.authType = AuthType::FACE;
217 info.publicKey.resize(32);
218 uint64_t index = 0;
219 std::vector<uint8_t> publicKey;
220 std::vector<uint64_t> templateIds;
221
222 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
223 EXPECT_NE(index, 0);
224 EXPECT_TRUE(!publicKey.empty());
225
226 index = 0;
227 publicKey.clear();
228 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
229 EXPECT_NE(index, 0);
230 EXPECT_TRUE(!publicKey.empty());
231
232 EXPECT_EQ(service->DeleteExecutor(index), 0);
233 }
234
235 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteExecutor_001, TestSize.Level0)
236 {
237 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
238 EXPECT_NE(service, nullptr);
239
240 EXPECT_EQ(service->Init(), 0);
241
242 uint64_t index1 = 1236584;
243 uint64_t index2 = 9895255;
244 EXPECT_EQ(service->DeleteExecutor(index1), 10006);
245 EXPECT_EQ(service->DeleteExecutor(index2), 10006);
246 }
247
248 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_001, TestSize.Level0)
249 {
250 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
251 EXPECT_NE(service, nullptr);
252
253 EXPECT_EQ(service->Init(), 0);
254
255 int32_t userId = 123456;
256 std::vector<uint8_t> authToken(10, 1);
257 EnrollParam param = {};
258 ScheduleInfo scheduleInfo = {};
259 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 8);
260 }
261
262 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_002, TestSize.Level0)
263 {
264 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
265 EXPECT_NE(service, nullptr);
266
267 EXPECT_EQ(service->Init(), 0);
268
269 int32_t userId = 123456;
270 std::vector<uint8_t> authToken;
271 EnrollParam param = {};
272 ScheduleInfo scheduleInfo = {};
273 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), RESULT_GENERAL_ERROR);
274 }
275
276 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_003, TestSize.Level0)
277 {
278 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
279 EXPECT_NE(service, nullptr);
280
281 EXPECT_EQ(service->Init(), 0);
282
283 int32_t userId = 123456;
284
285 std::vector<uint8_t> challenge;
286 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
287
288 std::vector<uint8_t> authToken;
289 EnrollParam param = {};
290 ScheduleInfo scheduleInfo = {};
291 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 10018);
292
293 EXPECT_EQ(service->CloseSession(userId), 0);
294 }
295
296 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_004, TestSize.Level0)
297 {
298 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
299 EXPECT_NE(service, nullptr);
300
301 EXPECT_EQ(service->Init(), 0);
302
303 int32_t userId = 123456;
304
305 std::vector<uint8_t> challenge;
306 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
307
308 std::vector<uint8_t> authToken;
309 EnrollParam param = {};
310 param.authType = AuthType::PIN;
311 ScheduleInfo scheduleInfo = {};
312 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 10004);
313
314 EXPECT_EQ(service->CloseSession(userId), 0);
315 }
316
317 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_005, TestSize.Level0)
318 {
319 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
320 EXPECT_NE(service, nullptr);
321
322 EXPECT_EQ(service->Init(), 0);
323
324 int32_t userId = 123456;
325
326 std::vector<uint8_t> challenge;
327 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
328
329 ExecutorRegisterInfo info = {};
330 info.authType = AuthType::PIN;
331 info.executorRole = ExecutorRole::ALL_IN_ONE;
332 info.esl = ExecutorSecureLevel::ESL0;
333 info.publicKey.resize(32);
334 uint64_t index = 0;
335 std::vector<uint8_t> publicKey;
336 std::vector<uint64_t> templateIds;
337
338 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
339 EXPECT_NE(index, 0);
340 EXPECT_FALSE(publicKey.empty());
341
342 std::vector<uint8_t> authToken;
343 EnrollParam param = {};
344 param.authType = AuthType::PIN;
345 ScheduleInfo scheduleInfo = {};
346 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 0);
347 EXPECT_EQ(service->CancelEnrollment(userId), 0);
348
349 EXPECT_EQ(service->DeleteExecutor(index), 0);
350 EXPECT_EQ(service->CloseSession(userId), 0);
351 }
352
353 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollmentV1_1_001, TestSize.Level0)
354 {
355 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
356 EXPECT_NE(service, nullptr);
357
358 EXPECT_EQ(service->Init(), 0);
359
360 int32_t userId = 123456;
361 std::vector<uint8_t> authToken(10, 1);
362 EnrollParam param = {};
363 ScheduleInfoV1_1 scheduleInfo = {};
364 EXPECT_EQ(service->BeginEnrollmentV1_1(userId, authToken, param, scheduleInfo), 8);
365 }
366
367 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollmentV1_1_002, TestSize.Level0)
368 {
369 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
370 EXPECT_NE(service, nullptr);
371
372 EXPECT_EQ(service->Init(), 0);
373
374 int32_t userId = 123456;
375 std::vector<uint8_t> authToken;
376 EnrollParam param = {};
377 ScheduleInfoV1_1 scheduleInfo = {};
378 EXPECT_EQ(service->BeginEnrollmentV1_1(userId, authToken, param, scheduleInfo), RESULT_GENERAL_ERROR);
379 }
380
381 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollmentV1_1_003, TestSize.Level0)
382 {
383 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
384 EXPECT_NE(service, nullptr);
385
386 EXPECT_EQ(service->Init(), 0);
387
388 int32_t userId = 123456;
389
390 std::vector<uint8_t> challenge;
391 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
392
393 std::vector<uint8_t> authToken;
394 EnrollParam param = {};
395 ScheduleInfoV1_1 scheduleInfo = {};
396 EXPECT_EQ(service->BeginEnrollmentV1_1(userId, authToken, param, scheduleInfo), 10018);
397
398 EXPECT_EQ(service->CloseSession(userId), 0);
399 }
400
401 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollmentV1_1_004, TestSize.Level0)
402 {
403 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
404 EXPECT_NE(service, nullptr);
405
406 EXPECT_EQ(service->Init(), 0);
407
408 int32_t userId = 123456;
409
410 std::vector<uint8_t> challenge;
411 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
412
413 std::vector<uint8_t> authToken;
414 EnrollParam param = {};
415 param.authType = AuthType::PIN;
416 ScheduleInfoV1_1 scheduleInfo = {};
417 EXPECT_EQ(service->BeginEnrollmentV1_1(userId, authToken, param, scheduleInfo), 10004);
418
419 EXPECT_EQ(service->CloseSession(userId), 0);
420 }
421
422 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollmentV1_1_005, TestSize.Level0)
423 {
424 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
425 EXPECT_NE(service, nullptr);
426
427 EXPECT_EQ(service->Init(), 0);
428
429 int32_t userId = 123456;
430
431 std::vector<uint8_t> challenge;
432 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
433
434 ExecutorRegisterInfo info = {};
435 info.authType = AuthType::PIN;
436 info.executorRole = ExecutorRole::ALL_IN_ONE;
437 info.esl = ExecutorSecureLevel::ESL0;
438 info.publicKey.resize(32);
439 uint64_t index = 0;
440 std::vector<uint8_t> publicKey;
441 std::vector<uint64_t> templateIds;
442
443 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
444 EXPECT_NE(index, 0);
445 EXPECT_FALSE(publicKey.empty());
446
447 std::vector<uint8_t> authToken;
448 EnrollParam param = {};
449 param.authType = AuthType::PIN;
450 ScheduleInfoV1_1 scheduleInfo = {};
451 EXPECT_EQ(service->BeginEnrollmentV1_1(userId, authToken, param, scheduleInfo), 0);
452 EXPECT_EQ(service->CancelEnrollment(userId), 0);
453
454 EXPECT_EQ(service->DeleteExecutor(index), 0);
455 EXPECT_EQ(service->CloseSession(userId), 0);
456 }
457
458 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_001, TestSize.Level0)
459 {
460 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
461 EXPECT_NE(service, nullptr);
462
463 EXPECT_EQ(service->Init(), 0);
464
465 int32_t userId = 6978465;
466 std::vector<uint8_t> scheduleResult;
467 EnrollResultInfo enrolledResultInfo = {};
468 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 8);
469 }
470
471 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_002, TestSize.Level0)
472 {
473 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
474 EXPECT_NE(service, nullptr);
475
476 EXPECT_EQ(service->Init(), 0);
477
478 int32_t userId = 6978465;
479 std::vector<uint8_t> scheduleResult(600000, 1);
480 EnrollResultInfo enrolledResultInfo = {};
481 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10004);
482 }
483
484 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_003, TestSize.Level0)
485 {
486 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
487 EXPECT_NE(service, nullptr);
488
489 EXPECT_EQ(service->Init(), 0);
490
491 int32_t userId = 6978465;
492 std::vector<uint8_t> scheduleResult(100, 1);
493 EnrollResultInfo enrolledResultInfo = {};
494 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
495 }
496
497 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_004, TestSize.Level0)
498 {
499 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
500 EXPECT_NE(service, nullptr);
501
502 EXPECT_EQ(service->Init(), 0);
503
504 int32_t userId = 6978465;
505 std::vector<uint8_t> challenge;
506 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
507
508 std::vector<uint8_t> scheduleResult(100, 1);
509 EnrollResultInfo enrolledResultInfo = {};
510 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
511
512 EXPECT_EQ(service->CloseSession(userId), 0);
513 }
514
515 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_005, TestSize.Level0)
516 {
517 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
518 EXPECT_NE(service, nullptr);
519
520 EXPECT_EQ(service->Init(), 0);
521
522 int32_t userId = 6978465;
523 std::vector<uint8_t> challenge;
524 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
525
526 ExecutorRegisterInfo info = {};
527 info.authType = AuthType::PIN;
528 info.executorRole = ExecutorRole::ALL_IN_ONE;
529 info.esl = ExecutorSecureLevel::ESL0;
530 info.publicKey.resize(32);
531 uint64_t index = 0;
532 std::vector<uint8_t> publicKey;
533 std::vector<uint64_t> templateIds;
534
535 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
536
537 std::vector<uint8_t> authToken;
538 EnrollParam param = {};
539 param.authType = AuthType::PIN;
540 ScheduleInfo scheduleInfo = {};
541 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 0);
542
543 std::vector<uint8_t> scheduleResult(100, 1);
544 EnrollResultInfo enrolledResultInfo = {};
545 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10012);
546
547 EXPECT_EQ(service->DeleteExecutor(index), 0);
548 EXPECT_EQ(service->CloseSession(userId), 0);
549 }
550
551 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_006, TestSize.Level0)
552 {
553 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
554 EXPECT_NE(service, nullptr);
555
556 EXPECT_EQ(service->Init(), 0);
557
558 int32_t userId = 6978465;
559 std::vector<uint8_t> challenge;
560 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
561
562 RegisterAllExecutor(service);
563
564 AuthType authType = AuthType::PIN;
565 std::vector<uint8_t> authToken;
566 EnrollResultTest enrollResultTest = {};
567 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
568 EXPECT_EQ(enrollResultTest.result, 0);
569
570 std::vector<CredentialInfo> deletedCredInfos;
571 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
572 EXPECT_TRUE(!deletedCredInfos.empty());
573
574 DeleteAllExecutor(service);
575 EXPECT_EQ(service->CloseSession(userId), 0);
576 }
577
578 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_001, TestSize.Level0)
579 {
580 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
581 EXPECT_NE(service, nullptr);
582
583 EXPECT_EQ(service->Init(), 0);
584
585 int32_t userId = 6978465;
586 EXPECT_EQ(service->CancelEnrollment(userId), 0);
587 }
588
589 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_002, TestSize.Level0)
590 {
591 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
592 EXPECT_NE(service, nullptr);
593
594 EXPECT_EQ(service->Init(), 0);
595
596 int32_t userId = 6978465;
597 std::vector<uint8_t> challenge;
598 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
599 EXPECT_EQ(service->CancelEnrollment(userId), 0);
600 EXPECT_EQ(service->CloseSession(userId), 0);
601 }
602
603 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_001, TestSize.Level0)
604 {
605 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
606 EXPECT_NE(service, nullptr);
607
608 EXPECT_EQ(service->Init(), 0);
609
610 uint64_t contextId = 123456;
611 AuthSolution param = {};
612 param.challenge.resize(100);
613 std::vector<ScheduleInfo> scheduleInfos;
614 EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10003);
615 }
616
617 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_002, TestSize.Level0)
618 {
619 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
620 EXPECT_NE(service, nullptr);
621
622 EXPECT_EQ(service->Init(), 0);
623
624 uint64_t contextId = 123456;
625 AuthSolution param = {};
626 std::vector<ScheduleInfo> scheduleInfos;
627 EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10);
628 }
629
630 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthenticationV1_1_001, TestSize.Level0)
631 {
632 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
633 EXPECT_NE(service, nullptr);
634
635 EXPECT_EQ(service->Init(), 0);
636
637 uint64_t contextId = 123456;
638 AuthSolution param = {};
639 param.challenge.resize(100);
640 std::vector<ScheduleInfoV1_1> scheduleInfos;
641 EXPECT_EQ(service->BeginAuthenticationV1_1(contextId, param, scheduleInfos), 10003);
642 }
643
644 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthenticationV1_1_002, TestSize.Level0)
645 {
646 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
647 EXPECT_NE(service, nullptr);
648
649 EXPECT_EQ(service->Init(), 0);
650
651 uint64_t contextId = 123456;
652 AuthSolution param = {};
653 std::vector<ScheduleInfoV1_1> scheduleInfos;
654 EXPECT_EQ(service->BeginAuthenticationV1_1(contextId, param, scheduleInfos), 10);
655 }
656
657 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_001, TestSize.Level0)
658 {
659 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
660 EXPECT_NE(service, nullptr);
661
662 EXPECT_EQ(service->Init(), 0);
663
664 uint64_t contextId = 123456;
665 std::vector<uint8_t> scheduleResult;
666 AuthResultInfo authResultInfo = {};
667 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), 8);
668 }
669
670 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_002, TestSize.Level0)
671 {
672 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
673 EXPECT_NE(service, nullptr);
674
675 EXPECT_EQ(service->Init(), 0);
676
677 uint64_t contextId = 123456;
678 std::vector<uint8_t> scheduleResult(600000, 1);
679 AuthResultInfo authResultInfo = {};
680 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), 10004);
681 }
682
683 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_003, TestSize.Level0)
684 {
685 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
686 EXPECT_NE(service, nullptr);
687
688 EXPECT_EQ(service->Init(), 0);
689
690 uint64_t contextId = 123456;
691 std::vector<uint8_t> scheduleResult;
692 scheduleResult.resize(sizeof(ExecutorResultInfo));
693 AuthResultInfo authResultInfo = {};
694 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), RESULT_GENERAL_ERROR);
695 }
696
697 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_004, TestSize.Level0)
698 {
699 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
700 EXPECT_NE(service, nullptr);
701
702 EXPECT_EQ(service->Init(), 0);
703
704 int32_t userId = 314265;
705 std::vector<uint8_t> challenge;
706 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
707
708 RegisterAllExecutor(service);
709
710 AuthType authType = AuthType::PIN;
711 std::vector<uint8_t> authToken;
712 EnrollResultTest enrollResultTest = {};
713 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
714 EXPECT_EQ(enrollResultTest.result, 0);
715
716 AuthResultTest authResultTest = {};
717 DoOnceAuth(service, userId, authType, challenge, authResultTest);
718 EXPECT_EQ(authResultTest.result, 0);
719
720 std::vector<CredentialInfo> deletedCredInfos;
721 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
722 EXPECT_TRUE(!deletedCredInfos.empty());
723
724 DeleteAllExecutor(service);
725 EXPECT_EQ(service->CloseSession(userId), 0);
726 }
727
728 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_001, TestSize.Level0)
729 {
730 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
731 EXPECT_NE(service, nullptr);
732
733 EXPECT_EQ(service->Init(), 0);
734
735 uint64_t contextId = 256487;
736 EXPECT_EQ(service->CancelAuthentication(contextId), 10006);
737 }
738
739 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_002, TestSize.Level0)
740 {
741 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
742 EXPECT_NE(service, nullptr);
743
744 EXPECT_EQ(service->Init(), 0);
745
746 int32_t userId = 314265;
747 std::vector<uint8_t> challenge;
748 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
749
750 RegisterAllExecutor(service);
751
752 AuthType authType = AuthType::PIN;
753 std::vector<uint8_t> authToken;
754 EnrollResultTest enrollResultTest = {};
755 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
756 EXPECT_EQ(enrollResultTest.result, 0);
757
758 uint64_t contextId = 653497;
759 AuthSolution authParam = {};
760 authParam.userId = userId;
761 authParam.authTrustLevel = 10000;
762 authParam.authType = authType;
763 authParam.challenge = challenge;
764 std::vector<ScheduleInfo> scheduleInfos;
765 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
766 EXPECT_TRUE(!scheduleInfos.empty());
767
768 EXPECT_EQ(service->CancelAuthentication(contextId), 0);
769
770 std::vector<CredentialInfo> deletedCredInfos;
771 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
772 EXPECT_TRUE(!deletedCredInfos.empty());
773
774 DeleteAllExecutor(service);
775 EXPECT_EQ(service->CloseSession(userId), 0);
776 }
777
778 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_001, TestSize.Level0)
779 {
780 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
781 EXPECT_NE(service, nullptr);
782
783 EXPECT_EQ(service->Init(), 0);
784
785 uint64_t contextId = 123456;
786 AuthType authType = AuthType::PIN;
787 std::vector<uint8_t> challenge;
788 uint32_t executorSensorHint = 0;
789 ScheduleInfo scheduleInfo = {};
790
791 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 8);
792 }
793
794 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_002, TestSize.Level0)
795 {
796 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
797 EXPECT_NE(service, nullptr);
798
799 EXPECT_EQ(service->Init(), 0);
800
801 uint64_t contextId = 623159;
802 AuthType authType = AuthType::FACE;
803 std::vector<uint8_t> challenge;
804 uint32_t executorSensorHint = 0;
805 ScheduleInfo scheduleInfo = {};
806
807 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 2);
808 }
809
810 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_003, TestSize.Level0)
811 {
812 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
813 EXPECT_NE(service, nullptr);
814
815 EXPECT_EQ(service->Init(), 0);
816
817 ExecutorRegisterInfo info = {};
818 info.authType = AuthType::FACE;
819 info.executorRole = ExecutorRole::ALL_IN_ONE;
820 info.esl = ExecutorSecureLevel::ESL0;
821 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
822 uint64_t index = 0;
823 std::vector<uint8_t> publicKey;
824 std::vector<uint64_t> templateIds;
825 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
826
827 uint64_t contextId = 623159;
828 AuthType authType = AuthType::FACE;
829 std::vector<uint8_t> challenge;
830 uint32_t executorSensorHint = 0;
831 ScheduleInfo scheduleInfo = {};
832 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
833
834 EXPECT_EQ(service->DeleteExecutor(index), 0);
835 }
836
837 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentificationV1_1_001, TestSize.Level0)
838 {
839 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
840 EXPECT_NE(service, nullptr);
841
842 EXPECT_EQ(service->Init(), 0);
843
844 uint64_t contextId = 123456;
845 AuthType authType = AuthType::PIN;
846 std::vector<uint8_t> challenge;
847 uint32_t executorSensorHint = 0;
848 ScheduleInfoV1_1 scheduleInfo = {};
849
850 EXPECT_EQ(service->BeginIdentificationV1_1(contextId, authType, challenge, executorSensorHint, scheduleInfo), 8);
851 }
852
853 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentificationV1_1_002, TestSize.Level0)
854 {
855 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
856 EXPECT_NE(service, nullptr);
857
858 EXPECT_EQ(service->Init(), 0);
859
860 uint64_t contextId = 623159;
861 AuthType authType = AuthType::FACE;
862 std::vector<uint8_t> challenge;
863 uint32_t executorSensorHint = 0;
864 ScheduleInfoV1_1 scheduleInfo = {};
865
866 EXPECT_EQ(service->BeginIdentificationV1_1(contextId, authType, challenge, executorSensorHint, scheduleInfo), 2);
867 }
868
869 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentificationV1_1_003, TestSize.Level0)
870 {
871 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
872 EXPECT_NE(service, nullptr);
873
874 EXPECT_EQ(service->Init(), 0);
875
876 ExecutorRegisterInfo info = {};
877 info.authType = AuthType::FACE;
878 info.executorRole = ExecutorRole::ALL_IN_ONE;
879 info.esl = ExecutorSecureLevel::ESL0;
880 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
881 uint64_t index = 0;
882 std::vector<uint8_t> publicKey;
883 std::vector<uint64_t> templateIds;
884 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
885
886 uint64_t contextId = 623159;
887 AuthType authType = AuthType::FACE;
888 std::vector<uint8_t> challenge;
889 uint32_t executorSensorHint = 0;
890 ScheduleInfoV1_1 scheduleInfo = {};
891 EXPECT_EQ(service->BeginIdentificationV1_1(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
892
893 EXPECT_EQ(service->DeleteExecutor(index), 0);
894 }
895
896 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_001, TestSize.Level0)
897 {
898 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
899 EXPECT_NE(service, nullptr);
900
901 EXPECT_EQ(service->Init(), 0);
902
903 uint64_t contextId = 621327;
904 std::vector<uint8_t> scheduleResult;
905 IdentifyResultInfo identityResultInfo = {};
906 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), 8);
907
908 scheduleResult.resize(240);
909 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), RESULT_GENERAL_ERROR);
910 }
911
912 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_002, TestSize.Level0)
913 {
914 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
915 EXPECT_NE(service, nullptr);
916
917 EXPECT_EQ(service->Init(), 0);
918
919 int32_t userId = 314265;
920 std::vector<uint8_t> challenge;
921 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
922
923 RegisterAllExecutor(service);
924
925 EnrollResultTest enrollPinResultTest = {};
926 std::vector<uint8_t> authToken;
927 DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
928 EXPECT_EQ(enrollPinResultTest.result, 0);
929
930 AuthResultTest authResultTest = {};
931 DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
932 EXPECT_EQ(authResultTest.result, 0);
933
934 EnrollResultTest enrollFaceResultTest = {};
935 DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
936 EXPECT_EQ(enrollFaceResultTest.result, 0);
937
938 uint64_t contextId = 623159;
939 AuthType authType = AuthType::FACE;
940 uint32_t executorSensorHint = 0;
941 ScheduleInfo scheduleInfo = {};
942 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
943
944 std::vector<uint8_t> identityScheduleResult;
945 TlvRequiredPara para = {};
946 para.result = 0;
947 para.scheduleId = scheduleInfo.scheduleId;
948 para.subType = 10000;
949 para.templateId = 20;
950 para.remainAttempts = 5;
951 EXPECT_EQ(GetExecutorResultTlv(para, identityScheduleResult), 0);
952 IdentifyResultInfo identityResultInfo = {};
953 EXPECT_EQ(service->UpdateIdentificationResult(contextId, identityScheduleResult, identityResultInfo), 0);
954
955 std::vector<CredentialInfo> deletedCredInfos;
956 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
957 EXPECT_TRUE(!deletedCredInfos.empty());
958
959 DeleteAllExecutor(service);
960 EXPECT_EQ(service->CloseSession(userId), 0);
961 }
962
963 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_001, TestSize.Level0)
964 {
965 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
966 EXPECT_NE(service, nullptr);
967
968 EXPECT_EQ(service->Init(), 0);
969
970 uint64_t contextId = 653215;
971 EXPECT_EQ(service->CancelIdentification(contextId), 10006);
972 }
973
974 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_002, TestSize.Level0)
975 {
976 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
977 EXPECT_NE(service, nullptr);
978
979 EXPECT_EQ(service->Init(), 0);
980
981 int32_t userId = 314265;
982 std::vector<uint8_t> challenge;
983 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
984
985 RegisterAllExecutor(service);
986
987 EnrollResultTest enrollPinResultTest = {};
988 std::vector<uint8_t> authToken;
989 DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
990 EXPECT_EQ(enrollPinResultTest.result, 0);
991
992 AuthResultTest authResultTest = {};
993 DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
994 EXPECT_EQ(authResultTest.result, 0);
995
996 EnrollResultTest enrollFaceResultTest = {};
997 DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
998 EXPECT_EQ(enrollFaceResultTest.result, 0);
999
1000 uint64_t contextId = 623159;
1001 AuthType authType = AuthType::FACE;
1002 uint32_t executorSensorHint = 0;
1003 ScheduleInfo scheduleInfo = {};
1004 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
1005
1006 EXPECT_EQ(service->CancelIdentification(contextId), 0);
1007
1008 std::vector<CredentialInfo> deletedCredInfos;
1009 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1010 EXPECT_TRUE(!deletedCredInfos.empty());
1011
1012 DeleteAllExecutor(service);
1013 EXPECT_EQ(service->CloseSession(userId), 0);
1014 }
1015
1016 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_001, TestSize.Level0)
1017 {
1018 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1019 EXPECT_NE(service, nullptr);
1020
1021 EXPECT_EQ(service->Init(), 0);
1022
1023 int32_t userId = 635648;
1024 AuthType authType = AuthType::PIN;
1025 std::vector<CredentialInfo> credInfos;
1026
1027 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
1028 EXPECT_TRUE(credInfos.empty());
1029 }
1030
1031 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_002, TestSize.Level0)
1032 {
1033 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1034 EXPECT_NE(service, nullptr);
1035
1036 EXPECT_EQ(service->Init(), 0);
1037
1038 int32_t userId = 635648;
1039 AuthType authType = AuthType::PIN;
1040 std::vector<uint8_t> challenge;
1041 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1042
1043 RegisterAllExecutor(service);
1044
1045 std::vector<uint8_t> authToken;
1046 EnrollResultTest enrollResultTest = {};
1047 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1048 EXPECT_EQ(enrollResultTest.result, 0);
1049
1050 std::vector<CredentialInfo> credInfos;
1051 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
1052 EXPECT_TRUE(!credInfos.empty());
1053
1054 std::vector<CredentialInfo> deletedCredInfos;
1055 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1056 EXPECT_TRUE(!deletedCredInfos.empty());
1057
1058 DeleteAllExecutor(service);
1059 EXPECT_EQ(service->CloseSession(userId), 0);
1060 }
1061
1062 HWTEST_F(UserAuthInterfaceServiceTest, TestGetUserInfo_001, TestSize.Level0)
1063 {
1064 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1065 EXPECT_NE(service, nullptr);
1066
1067 EXPECT_EQ(service->Init(), 0);
1068
1069 int32_t userId = 635648;
1070 AuthType authType = AuthType::PIN;
1071 std::vector<uint8_t> challenge;
1072 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1073
1074 RegisterAllExecutor(service);
1075
1076 std::vector<uint8_t> authToken;
1077 EnrollResultTest enrollResultTest = {};
1078 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1079 EXPECT_EQ(enrollResultTest.result, 0);
1080
1081 uint64_t secureUid = 0;
1082 PinSubType subType = PinSubType::PIN_SIX;
1083 std::vector<EnrolledInfo> enrolledInfos;
1084 EXPECT_EQ(service->GetUserInfo(userId, secureUid, subType, enrolledInfos), 0);
1085 EXPECT_TRUE(!enrolledInfos.empty());
1086
1087 std::vector<CredentialInfo> deletedCredInfos;
1088 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1089 EXPECT_TRUE(!deletedCredInfos.empty());
1090
1091 DeleteAllExecutor(service);
1092 EXPECT_EQ(service->CloseSession(userId), 0);
1093 }
1094
1095 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_001, TestSize.Level0)
1096 {
1097 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1098 EXPECT_NE(service, nullptr);
1099
1100 EXPECT_EQ(service->Init(), 0);
1101
1102 int32_t userId = 321657;
1103 std::vector<uint8_t> authToken;
1104 std::vector<CredentialInfo> deletedCredInfos;
1105 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos), 8);
1106
1107 authToken.resize(sizeof(UserAuthTokenHal));
1108 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos), 10017);
1109 }
1110
1111 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_002, TestSize.Level0)
1112 {
1113 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1114 EXPECT_NE(service, nullptr);
1115
1116 EXPECT_EQ(service->Init(), 0);
1117
1118 int32_t userId = 321657;
1119 AuthType authType = AuthType::PIN;
1120 std::vector<uint8_t> challenge;
1121 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1122
1123 RegisterAllExecutor(service);
1124
1125 std::vector<uint8_t> authToken;
1126 EnrollResultTest enrollResultTest = {};
1127 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1128 EXPECT_EQ(enrollResultTest.result, 0);
1129
1130 AuthResultTest authResultTest = {};
1131 DoOnceAuth(service, userId, authType, challenge, authResultTest);
1132 EXPECT_EQ(authResultTest.result, 0);
1133
1134 std::vector<CredentialInfo> deletedCredInfos;
1135 EXPECT_EQ(service->DeleteUser(userId, authResultTest.token, deletedCredInfos), 0);
1136 EXPECT_TRUE(!deletedCredInfos.empty());
1137
1138 DeleteAllExecutor(service);
1139 EXPECT_EQ(service->CloseSession(userId), 0);
1140 }
1141
1142 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_001, TestSize.Level0)
1143 {
1144 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1145 EXPECT_NE(service, nullptr);
1146
1147 EXPECT_EQ(service->Init(), 0);
1148
1149 int32_t userId = 635678;
1150 std::vector<CredentialInfo> deletedCredInfos;
1151 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 10006);
1152 EXPECT_TRUE(deletedCredInfos.empty());
1153 }
1154
1155 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_002, TestSize.Level0)
1156 {
1157 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1158 EXPECT_NE(service, nullptr);
1159
1160 EXPECT_EQ(service->Init(), 0);
1161
1162 int32_t userId = 635678;
1163 AuthType authType = AuthType::PIN;
1164 std::vector<uint8_t> challenge;
1165 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1166
1167 RegisterAllExecutor(service);
1168
1169 std::vector<uint8_t> authToken;
1170 EnrollResultTest enrollResultTest = {};
1171 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1172 EXPECT_EQ(enrollResultTest.result, 0);
1173
1174 std::vector<CredentialInfo> deletedCredInfos;
1175 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1176 EXPECT_TRUE(!deletedCredInfos.empty());
1177
1178 DeleteAllExecutor(service);
1179 EXPECT_EQ(service->CloseSession(userId), 0);
1180 }
1181
1182 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAuthTrustLevel_001, TestSize.Level0)
1183 {
1184 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1185 EXPECT_NE(service, nullptr);
1186
1187 EXPECT_EQ(service->Init(), 0);
1188
1189 int32_t userId = 325614;
1190 AuthType authType = AuthType::PIN;
1191 uint32_t authTrustLevel = 0;
1192 EXPECT_EQ(service->GetAuthTrustLevel(userId, authType, authTrustLevel), 5);
1193 }
1194
1195 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAuthTrustLevel_002, TestSize.Level0)
1196 {
1197 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1198 EXPECT_NE(service, nullptr);
1199
1200 EXPECT_EQ(service->Init(), 0);
1201
1202 int32_t userId = 325614;
1203 AuthType authType = AuthType::PIN;
1204 std::vector<uint8_t> challenge;
1205 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1206
1207 RegisterAllExecutor(service);
1208
1209 std::vector<uint8_t> authToken;
1210 EnrollResultTest enrollResultTest = {};
1211 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1212 EXPECT_EQ(enrollResultTest.result, 0);
1213
1214 uint32_t authTrustLevel = 0;
1215 EXPECT_EQ(service->GetAuthTrustLevel(userId, authType, authTrustLevel), 0);
1216
1217 std::vector<CredentialInfo> deletedCredInfos;
1218 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1219 EXPECT_TRUE(!deletedCredInfos.empty());
1220
1221 DeleteAllExecutor(service);
1222 EXPECT_EQ(service->CloseSession(userId), 0);
1223 }
1224
1225 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdatePin, TestSize.Level0)
1226 {
1227 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1228 EXPECT_NE(service, nullptr);
1229
1230 EXPECT_EQ(service->Init(), 0);
1231
1232 int32_t userId = 325678;
1233 AuthType authType = AuthType::PIN;
1234 std::vector<uint8_t> challenge;
1235 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1236
1237 RegisterAllExecutor(service);
1238
1239 std::vector<uint8_t> authToken;
1240 EnrollResultTest enrollResultTest = {};
1241 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1242 EXPECT_EQ(enrollResultTest.result, 0);
1243
1244 AuthResultTest authResultTest = {};
1245 DoOnceAuth(service, userId, authType, challenge, authResultTest);
1246 EXPECT_EQ(authResultTest.result, 0);
1247
1248 DoOnceEnroll(service, userId, authType, authResultTest.token, enrollResultTest);
1249 EXPECT_EQ(enrollResultTest.result, 0);
1250
1251 std::vector<CredentialInfo> deletedCredInfos;
1252 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1253 EXPECT_TRUE(!deletedCredInfos.empty());
1254
1255 DeleteAllExecutor(service);
1256 EXPECT_EQ(service->CloseSession(userId), 0);
1257 }
1258
1259 HWTEST_F(UserAuthInterfaceServiceTest, TestEnrollTwice, TestSize.Level0)
1260 {
1261 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1262 EXPECT_NE(service, nullptr);
1263
1264 EXPECT_EQ(service->Init(), 0);
1265
1266 int32_t userId = 363156;
1267 AuthType authType = AuthType::PIN;
1268 std::vector<uint8_t> challenge;
1269 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1270
1271 RegisterAllExecutor(service);
1272
1273 std::vector<uint8_t> authToken;
1274 EnrollResultTest enrollResultTest = {};
1275 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1276 EXPECT_EQ(enrollResultTest.result, 0);
1277
1278 EnrollParam enrollParam = {};
1279 enrollParam.authType = authType;
1280 ScheduleInfo scheduleInfo = {};
1281 EXPECT_EQ(service->BeginEnrollment(userId, authToken, enrollParam, scheduleInfo), 10018);
1282
1283 std::vector<CredentialInfo> deletedCredInfos;
1284 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1285 EXPECT_TRUE(!deletedCredInfos.empty());
1286
1287 DeleteAllExecutor(service);
1288 EXPECT_EQ(service->CloseSession(userId), 0);
1289 }
1290
1291 HWTEST_F(UserAuthInterfaceServiceTest, TestInitTwice, TestSize.Level0)
1292 {
1293 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1294 EXPECT_NE(service, nullptr);
1295
1296 EXPECT_EQ(service->Init(), 0);
1297
1298 int32_t userId = 368635;
1299 AuthType authType = AuthType::PIN;
1300 std::vector<uint8_t> challenge;
1301 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1302
1303 RegisterAllExecutor(service);
1304
1305 std::vector<uint8_t> authToken;
1306 EnrollResultTest enrollResultTest = {};
1307 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1308 EXPECT_EQ(enrollResultTest.result, 0);
1309
1310 EXPECT_EQ(service->Init(), 0);
1311
1312 std::vector<CredentialInfo> deletedCredInfos;
1313 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1314 EXPECT_TRUE(!deletedCredInfos.empty());
1315
1316 EXPECT_EQ(service->CloseSession(userId), 0);
1317 }
1318
1319 HWTEST_F(UserAuthInterfaceServiceTest, TestAuthLock, TestSize.Level0)
1320 {
1321 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1322 EXPECT_NE(service, nullptr);
1323
1324 EXPECT_EQ(service->Init(), 0);
1325
1326 int32_t userId = 365861;
1327 AuthType authType = AuthType::PIN;
1328 std::vector<uint8_t> challenge;
1329 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1330
1331 RegisterAllExecutor(service);
1332
1333 std::vector<uint8_t> authToken;
1334 EnrollResultTest enrollResultTest = {};
1335 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1336 EXPECT_EQ(enrollResultTest.result, 0);
1337
1338 uint64_t contextId = 636548;
1339 AuthSolution authParam = {};
1340 authParam.userId = userId;
1341 authParam.authTrustLevel = 10000;
1342 authParam.authType = authType;
1343 authParam.challenge = challenge;
1344 std::vector<ScheduleInfo> scheduleInfos;
1345 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
1346 EXPECT_TRUE(!scheduleInfos.empty());
1347
1348 std::vector<uint8_t> authScheduleResult;
1349 TlvRequiredPara para = {};
1350 para.result = 2;
1351 para.scheduleId = scheduleInfos[0].scheduleId;
1352 para.subType = 10000;
1353 para.templateId = 20;
1354 para.remainAttempts = 0;
1355 EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
1356 AuthResultInfo authResultInfo = {};
1357
1358 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo), 0);
1359
1360 std::vector<CredentialInfo> deletedCredInfos;
1361 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1362 EXPECT_TRUE(!deletedCredInfos.empty());
1363
1364 DeleteAllExecutor(service);
1365 EXPECT_EQ(service->CloseSession(userId), 0);
1366 }
1367 } // namespace UserAuth
1368 } // namespace HDI
1369 } // namespace OHOS