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 "v1_0/user_auth_interface_service.h"
24 #include "v1_0/user_auth_types.h"
25 #include "executor_message.h"
26 #include "user_sign_centre.h"
27 #include "signature_operation.h"
28
29 namespace OHOS {
30 namespace HDI {
31 namespace UserAuth {
32 namespace V1_0 {
33 using namespace testing;
34 using namespace testing::ext;
35
SetUpTestCase()36 void UserAuthInterfaceServiceTest::SetUpTestCase()
37 {
38 }
39
TearDownTestCase()40 void UserAuthInterfaceServiceTest::TearDownTestCase()
41 {
42 }
43
SetUp()44 void UserAuthInterfaceServiceTest::SetUp()
45 {
46 }
47
TearDown()48 void UserAuthInterfaceServiceTest::TearDown()
49 {
50 }
51
52 struct EnrollResultTest {
53 int32_t result;
54 uint64_t credentialId;
55 uint64_t executorIndex;
56 };
57
58 struct AuthResultTest {
59 int32_t result;
60 std::vector<uint8_t> token;
61 };
62
DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,const std::vector<uint8_t> & authToken,EnrollResultTest & enrollResultTest)63 void DoOnceEnroll(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
64 const std::vector<uint8_t> &authToken, EnrollResultTest &enrollResultTest)
65 {
66 ExecutorRegisterInfo info = {};
67 info.authType = authType;
68 info.executorRole = ALL_IN_ONE;
69 info.esl = ESL0;
70 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
71 uint64_t index = 0;
72 std::vector<uint8_t> publicKey;
73 std::vector<uint64_t> templateIds;
74
75 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
76
77 EnrollParam enrollParam = {};
78 enrollParam.authType = authType;
79 ScheduleInfo scheduleInfo = {};
80 EXPECT_EQ(service->BeginEnrollment(userId, authToken, enrollParam, scheduleInfo), 0);
81
82 EnrollResultInfo enrolledResultInfo = {};
83 std::vector<uint8_t> enrollScheduleResult;
84 TlvRequiredPara para = {};
85 para.result = 0;
86 para.scheduleId = scheduleInfo.scheduleId;
87 para.subType = 10000;
88 para.templateId = 20;
89 para.remainAttempts = 5;
90 EXPECT_EQ(GetExecutorResultTlv(para, enrollScheduleResult), 0);
91
92 enrollResultTest.result = service->UpdateEnrollmentResult(userId, enrollScheduleResult, enrolledResultInfo);
93 enrollResultTest.credentialId = enrolledResultInfo.credentialId;
94 enrollResultTest.executorIndex = index;
95 EXPECT_EQ(enrollResultTest.result, 0);
96 }
97
DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> & service,int32_t userId,AuthType authType,std::vector<uint8_t> & challenge,AuthResultTest & authResultTest)98 void DoOnceAuth(const std::shared_ptr<UserAuthInterfaceService> &service, int32_t userId, AuthType authType,
99 std::vector<uint8_t> &challenge, AuthResultTest &authResultTest)
100 {
101 uint64_t contextId = 636548;
102 AuthSolution authParam = {};
103 authParam.userId = userId;
104 authParam.authTrustLevel = 10000;
105 authParam.authType = authType;
106 authParam.challenge = challenge;
107 std::vector<ScheduleInfo> scheduleInfos;
108 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
109 EXPECT_TRUE(!scheduleInfos.empty());
110
111 std::vector<uint8_t> authScheduleResult;
112 TlvRequiredPara para = {};
113 para.result = 0;
114 para.scheduleId = scheduleInfos[0].scheduleId;
115 para.subType = 10000;
116 para.templateId = 20;
117 para.remainAttempts = 5;
118 EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
119 AuthResultInfo authResultInfo = {};
120
121 authResultTest.result = service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo);
122 EXPECT_EQ(authResultTest.result, 0);
123 authResultTest.token = authResultInfo.token;
124 }
125
126 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_001, TestSize.Level0)
127 {
128 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
129 EXPECT_NE(service, nullptr);
130 int32_t userId = 1245;
131 std::vector<uint8_t> challenge;
132 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
133 EXPECT_EQ(challenge.size(), 32);
134 EXPECT_EQ(service->CloseSession(userId), 0);
135 }
136
137 HWTEST_F(UserAuthInterfaceServiceTest, TestOpenSession_002, TestSize.Level0)
138 {
139 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
140 EXPECT_NE(service, nullptr);
141
142 int32_t userId1 = 1245;
143 std::vector<uint8_t> challenge1;
144 EXPECT_EQ(service->OpenSession(userId1, challenge1), 0);
145 EXPECT_EQ(challenge1.size(), 32);
146
147 int32_t userId2 = 2245;
148 std::vector<uint8_t> challenge2;
149 EXPECT_EQ(service->OpenSession(userId2, challenge2), 0);
150 EXPECT_EQ(challenge2.size(), 32);
151
152 EXPECT_EQ(service->CloseSession(userId1), 0);
153 EXPECT_EQ(service->CloseSession(userId2), 2);
154 }
155
156 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_001, TestSize.Level0)
157 {
158 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
159 EXPECT_NE(service, nullptr);
160
161 ExecutorRegisterInfo info = {};
162 uint64_t index = 0;
163 std::vector<uint8_t> publicKey;
164 std::vector<uint64_t> templateIds;
165 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 8);
166 }
167
168 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_002, TestSize.Level0)
169 {
170 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
171 EXPECT_NE(service, nullptr);
172
173 EXPECT_EQ(service->Init(), 0);
174
175 ExecutorRegisterInfo info = {};
176 info.authType = FACE;
177 info.publicKey.resize(32);
178 uint64_t index = 0;
179 std::vector<uint8_t> publicKey;
180 std::vector<uint64_t> templateIds;
181
182 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
183 EXPECT_NE(index, 0);
184 EXPECT_TRUE(!publicKey.empty());
185
186 EXPECT_EQ(service->DeleteExecutor(index), 0);
187 }
188
189 HWTEST_F(UserAuthInterfaceServiceTest, TestAddExecutor_003, TestSize.Level0)
190 {
191 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
192 EXPECT_NE(service, nullptr);
193
194 EXPECT_EQ(service->Init(), 0);
195
196 ExecutorRegisterInfo info = {};
197 info.authType = FACE;
198 info.publicKey.resize(32);
199 uint64_t index = 0;
200 std::vector<uint8_t> publicKey;
201 std::vector<uint64_t> templateIds;
202
203 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
204 EXPECT_NE(index, 0);
205 EXPECT_TRUE(!publicKey.empty());
206
207 index = 0;
208 publicKey.clear();
209 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
210 EXPECT_NE(index, 0);
211 EXPECT_TRUE(!publicKey.empty());
212
213 EXPECT_EQ(service->DeleteExecutor(index), 0);
214 }
215
216 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteExecutor_001, TestSize.Level0)
217 {
218 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
219 EXPECT_NE(service, nullptr);
220
221 EXPECT_EQ(service->Init(), 0);
222
223 uint64_t index1 = 1236584;
224 uint64_t index2 = 9895255;
225 EXPECT_EQ(service->DeleteExecutor(index1), 10006);
226 EXPECT_EQ(service->DeleteExecutor(index2), 10006);
227 }
228
229 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_001, TestSize.Level0)
230 {
231 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
232 EXPECT_NE(service, nullptr);
233
234 EXPECT_EQ(service->Init(), 0);
235
236 int32_t userId = 123456;
237 std::vector<uint8_t> authToken(10, 1);
238 EnrollParam param = {};
239 ScheduleInfo scheduleInfo = {};
240 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 8);
241 }
242
243 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_002, TestSize.Level0)
244 {
245 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
246 EXPECT_NE(service, nullptr);
247
248 EXPECT_EQ(service->Init(), 0);
249
250 int32_t userId = 123456;
251 std::vector<uint8_t> authToken;
252 EnrollParam param = {};
253 ScheduleInfo scheduleInfo = {};
254 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 8);
255 }
256
257 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_003, TestSize.Level0)
258 {
259 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
260 EXPECT_NE(service, nullptr);
261
262 EXPECT_EQ(service->Init(), 0);
263
264 int32_t userId = 123456;
265
266 std::vector<uint8_t> challenge;
267 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
268
269 std::vector<uint8_t> authToken;
270 EnrollParam param = {};
271 ScheduleInfo scheduleInfo = {};
272 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 10018);
273
274 EXPECT_EQ(service->CloseSession(userId), 0);
275 }
276
277 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_004, TestSize.Level0)
278 {
279 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
280 EXPECT_NE(service, nullptr);
281
282 EXPECT_EQ(service->Init(), 0);
283
284 int32_t userId = 123456;
285
286 std::vector<uint8_t> challenge;
287 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
288
289 std::vector<uint8_t> authToken;
290 EnrollParam param = {};
291 param.authType = PIN;
292 ScheduleInfo scheduleInfo = {};
293 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 10004);
294
295 EXPECT_EQ(service->CloseSession(userId), 0);
296 }
297
298 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginEnrollment_005, TestSize.Level0)
299 {
300 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
301 EXPECT_NE(service, nullptr);
302
303 EXPECT_EQ(service->Init(), 0);
304
305 int32_t userId = 123456;
306
307 std::vector<uint8_t> challenge;
308 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
309
310 ExecutorRegisterInfo info = {};
311 info.authType = PIN;
312 info.executorRole = ALL_IN_ONE;
313 info.esl = ESL0;
314 info.publicKey.resize(32);
315 uint64_t index = 0;
316 std::vector<uint8_t> publicKey;
317 std::vector<uint64_t> templateIds;
318
319 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
320 EXPECT_NE(index, 0);
321 EXPECT_FALSE(publicKey.empty());
322
323 std::vector<uint8_t> authToken;
324 EnrollParam param = {};
325 param.authType = PIN;
326 ScheduleInfo scheduleInfo = {};
327 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 0);
328 EXPECT_EQ(service->CancelEnrollment(userId), 0);
329
330 EXPECT_EQ(service->DeleteExecutor(index), 0);
331 EXPECT_EQ(service->CloseSession(userId), 0);
332 }
333
334 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_001, TestSize.Level0)
335 {
336 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
337 EXPECT_NE(service, nullptr);
338
339 EXPECT_EQ(service->Init(), 0);
340
341 int32_t userId = 6978465;
342 std::vector<uint8_t> scheduleResult;
343 EnrollResultInfo enrolledResultInfo = {};
344 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 8);
345 }
346
347 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_002, TestSize.Level0)
348 {
349 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
350 EXPECT_NE(service, nullptr);
351
352 EXPECT_EQ(service->Init(), 0);
353
354 int32_t userId = 6978465;
355 std::vector<uint8_t> scheduleResult(600000, 1);
356 EnrollResultInfo enrolledResultInfo = {};
357 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10004);
358 }
359
360 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_003, TestSize.Level0)
361 {
362 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
363 EXPECT_NE(service, nullptr);
364
365 EXPECT_EQ(service->Init(), 0);
366
367 int32_t userId = 6978465;
368 std::vector<uint8_t> scheduleResult(100, 1);
369 EnrollResultInfo enrolledResultInfo = {};
370 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
371 }
372
373 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_004, TestSize.Level0)
374 {
375 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
376 EXPECT_NE(service, nullptr);
377
378 EXPECT_EQ(service->Init(), 0);
379
380 int32_t userId = 6978465;
381 std::vector<uint8_t> challenge;
382 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
383
384 std::vector<uint8_t> scheduleResult(100, 1);
385 EnrollResultInfo enrolledResultInfo = {};
386 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10005);
387
388 EXPECT_EQ(service->CloseSession(userId), 0);
389 }
390
391 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_005, TestSize.Level0)
392 {
393 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
394 EXPECT_NE(service, nullptr);
395
396 EXPECT_EQ(service->Init(), 0);
397
398 int32_t userId = 6978465;
399 std::vector<uint8_t> challenge;
400 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
401
402 ExecutorRegisterInfo info = {};
403 info.authType = PIN;
404 info.executorRole = ALL_IN_ONE;
405 info.esl = ESL0;
406 info.publicKey.resize(32);
407 uint64_t index = 0;
408 std::vector<uint8_t> publicKey;
409 std::vector<uint64_t> templateIds;
410
411 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
412
413 std::vector<uint8_t> authToken;
414 EnrollParam param = {};
415 param.authType = PIN;
416 ScheduleInfo scheduleInfo = {};
417 EXPECT_EQ(service->BeginEnrollment(userId, authToken, param, scheduleInfo), 0);
418
419 std::vector<uint8_t> scheduleResult(100, 1);
420 EnrollResultInfo enrolledResultInfo = {};
421 EXPECT_EQ(service->UpdateEnrollmentResult(userId, scheduleResult, enrolledResultInfo), 10012);
422
423 EXPECT_EQ(service->DeleteExecutor(index), 0);
424 EXPECT_EQ(service->CloseSession(userId), 0);
425 }
426
427 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateEnrollmentResult_006, TestSize.Level0)
428 {
429 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
430 EXPECT_NE(service, nullptr);
431
432 EXPECT_EQ(service->Init(), 0);
433
434 int32_t userId = 6978465;
435 std::vector<uint8_t> challenge;
436 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
437
438 AuthType authType = PIN;
439 std::vector<uint8_t> authToken;
440 EnrollResultTest enrollResultTest = {};
441 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
442 EXPECT_EQ(enrollResultTest.result, 0);
443
444 std::vector<CredentialInfo> deletedCredInfos;
445 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
446 EXPECT_TRUE(!deletedCredInfos.empty());
447
448 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
449 EXPECT_EQ(service->CloseSession(userId), 0);
450 }
451
452 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_001, TestSize.Level0)
453 {
454 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
455 EXPECT_NE(service, nullptr);
456
457 EXPECT_EQ(service->Init(), 0);
458
459 int32_t userId = 6978465;
460 EXPECT_EQ(service->CancelEnrollment(userId), 0);
461 }
462
463 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelEnrollment_002, TestSize.Level0)
464 {
465 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
466 EXPECT_NE(service, nullptr);
467
468 EXPECT_EQ(service->Init(), 0);
469
470 int32_t userId = 6978465;
471 std::vector<uint8_t> challenge;
472 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
473 EXPECT_EQ(service->CancelEnrollment(userId), 0);
474 EXPECT_EQ(service->CloseSession(userId), 0);
475 }
476
477 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_001, TestSize.Level0)
478 {
479 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
480 EXPECT_NE(service, nullptr);
481
482 EXPECT_EQ(service->Init(), 0);
483
484 uint64_t contextId = 123456;
485 AuthSolution param = {};
486 param.challenge.resize(100);
487 std::vector<ScheduleInfo> scheduleInfos;
488 EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10003);
489 }
490
491 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginAuthentication_002, TestSize.Level0)
492 {
493 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
494 EXPECT_NE(service, nullptr);
495
496 EXPECT_EQ(service->Init(), 0);
497
498 uint64_t contextId = 123456;
499 AuthSolution param = {};
500 std::vector<ScheduleInfo> scheduleInfos;
501 EXPECT_EQ(service->BeginAuthentication(contextId, param, scheduleInfos), 10);
502 }
503
504 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_001, TestSize.Level0)
505 {
506 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
507 EXPECT_NE(service, nullptr);
508
509 EXPECT_EQ(service->Init(), 0);
510
511 uint64_t contextId = 123456;
512 std::vector<uint8_t> scheduleResult;
513 AuthResultInfo authResultInfo = {};
514 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), 8);
515 }
516
517 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_002, TestSize.Level0)
518 {
519 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
520 EXPECT_NE(service, nullptr);
521
522 EXPECT_EQ(service->Init(), 0);
523
524 uint64_t contextId = 123456;
525 std::vector<uint8_t> scheduleResult(600000, 1);
526 AuthResultInfo authResultInfo = {};
527 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), 10004);
528 }
529
530 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_003, TestSize.Level0)
531 {
532 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
533 EXPECT_NE(service, nullptr);
534
535 EXPECT_EQ(service->Init(), 0);
536
537 uint64_t contextId = 123456;
538 std::vector<uint8_t> scheduleResult;
539 scheduleResult.resize(sizeof(ExecutorResultInfo));
540 AuthResultInfo authResultInfo = {};
541 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, scheduleResult, authResultInfo), 10012);
542 }
543
544 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateAuthenticationResult_004, TestSize.Level0)
545 {
546 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
547 EXPECT_NE(service, nullptr);
548
549 EXPECT_EQ(service->Init(), 0);
550
551 int32_t userId = 314265;
552 std::vector<uint8_t> challenge;
553 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
554
555 AuthType authType = PIN;
556 std::vector<uint8_t> authToken;
557 EnrollResultTest enrollResultTest = {};
558 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
559 EXPECT_EQ(enrollResultTest.result, 0);
560
561 AuthResultTest authResultTest = {};
562 DoOnceAuth(service, userId, authType, challenge, authResultTest);
563 EXPECT_EQ(authResultTest.result, 0);
564
565 std::vector<CredentialInfo> deletedCredInfos;
566 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
567 EXPECT_TRUE(!deletedCredInfos.empty());
568
569 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
570 EXPECT_EQ(service->CloseSession(userId), 0);
571 }
572
573 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_001, TestSize.Level0)
574 {
575 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
576 EXPECT_NE(service, nullptr);
577
578 EXPECT_EQ(service->Init(), 0);
579
580 uint64_t contextId = 256487;
581 EXPECT_EQ(service->CancelAuthentication(contextId), 10006);
582 }
583
584 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_002, TestSize.Level0)
585 {
586 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
587 EXPECT_NE(service, nullptr);
588
589 EXPECT_EQ(service->Init(), 0);
590
591 int32_t userId = 314265;
592 std::vector<uint8_t> challenge;
593 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
594
595 AuthType authType = PIN;
596 std::vector<uint8_t> authToken;
597 EnrollResultTest enrollResultTest = {};
598 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
599 EXPECT_EQ(enrollResultTest.result, 0);
600
601 uint64_t contextId = 653497;
602 AuthSolution authParam = {};
603 authParam.userId = userId;
604 authParam.authTrustLevel = 10000;
605 authParam.authType = authType;
606 authParam.challenge = challenge;
607 std::vector<ScheduleInfo> scheduleInfos;
608 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
609 EXPECT_TRUE(!scheduleInfos.empty());
610
611 EXPECT_EQ(service->CancelAuthentication(contextId), 0);
612
613 std::vector<CredentialInfo> deletedCredInfos;
614 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
615 EXPECT_TRUE(!deletedCredInfos.empty());
616
617 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
618 EXPECT_EQ(service->CloseSession(userId), 0);
619 }
620
621 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_001, TestSize.Level0)
622 {
623 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
624 EXPECT_NE(service, nullptr);
625
626 EXPECT_EQ(service->Init(), 0);
627
628 uint64_t contextId = 123456;
629 AuthType authType = PIN;
630 std::vector<uint8_t> challenge;
631 uint32_t executorSensorHint = 0;
632 ScheduleInfo scheduleInfo = {};
633
634 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 8);
635 }
636
637 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_002, TestSize.Level0)
638 {
639 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
640 EXPECT_NE(service, nullptr);
641
642 EXPECT_EQ(service->Init(), 0);
643
644 uint64_t contextId = 623159;
645 AuthType authType = FACE;
646 std::vector<uint8_t> challenge;
647 uint32_t executorSensorHint = 0;
648 ScheduleInfo scheduleInfo = {};
649
650 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 2);
651 }
652
653 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_003, TestSize.Level0)
654 {
655 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
656 EXPECT_NE(service, nullptr);
657
658 EXPECT_EQ(service->Init(), 0);
659
660 ExecutorRegisterInfo info = {};
661 info.authType = FACE;
662 info.executorRole = ALL_IN_ONE;
663 info.esl = ESL0;
664 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
665 uint64_t index = 0;
666 std::vector<uint8_t> publicKey;
667 std::vector<uint64_t> templateIds;
668 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
669
670 uint64_t contextId = 623159;
671 AuthType authType = FACE;
672 std::vector<uint8_t> challenge;
673 uint32_t executorSensorHint = 0;
674 ScheduleInfo scheduleInfo = {};
675 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
676
677 EXPECT_EQ(service->DeleteExecutor(index), 0);
678 }
679
680 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_001, TestSize.Level0)
681 {
682 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
683 EXPECT_NE(service, nullptr);
684
685 EXPECT_EQ(service->Init(), 0);
686
687 uint64_t contextId = 621327;
688 std::vector<uint8_t> scheduleResult;
689 IdentifyResultInfo identityResultInfo = {};
690 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), 8);
691
692 scheduleResult.resize(240);
693 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), 10012);
694 }
695
696 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_002, TestSize.Level0)
697 {
698 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
699 EXPECT_NE(service, nullptr);
700
701 EXPECT_EQ(service->Init(), 0);
702
703 int32_t userId = 314265;
704 std::vector<uint8_t> challenge;
705 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
706
707 EnrollResultTest enrollPinResultTest = {};
708 std::vector<uint8_t> authToken;
709 DoOnceEnroll(service, userId, PIN, authToken, enrollPinResultTest);
710 EXPECT_EQ(enrollPinResultTest.result, 0);
711
712 AuthResultTest authResultTest = {};
713 DoOnceAuth(service, userId, PIN, challenge, authResultTest);
714 EXPECT_EQ(authResultTest.result, 0);
715
716 EnrollResultTest enrollFaceResultTest = {};
717 DoOnceEnroll(service, userId, FACE, authResultTest.token, enrollFaceResultTest);
718 EXPECT_EQ(enrollFaceResultTest.result, 0);
719
720 uint64_t contextId = 623159;
721 AuthType authType = FACE;
722 uint32_t executorSensorHint = 0;
723 ScheduleInfo scheduleInfo = {};
724 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
725
726 std::vector<uint8_t> identityScheduleResult;
727 TlvRequiredPara para = {};
728 para.result = 0;
729 para.scheduleId = scheduleInfo.scheduleId;
730 para.subType = 10000;
731 para.templateId = 20;
732 para.remainAttempts = 5;
733 EXPECT_EQ(GetExecutorResultTlv(para, identityScheduleResult), 0);
734 IdentifyResultInfo identityResultInfo = {};
735 EXPECT_EQ(service->UpdateIdentificationResult(contextId, identityScheduleResult, identityResultInfo), 0);
736
737 std::vector<CredentialInfo> deletedCredInfos;
738 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
739 EXPECT_TRUE(!deletedCredInfos.empty());
740
741 EXPECT_EQ(service->DeleteExecutor(enrollPinResultTest.executorIndex), 0);
742 EXPECT_EQ(service->DeleteExecutor(enrollFaceResultTest.executorIndex), 0);
743 EXPECT_EQ(service->CloseSession(userId), 0);
744 }
745
746 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_001, TestSize.Level0)
747 {
748 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
749 EXPECT_NE(service, nullptr);
750
751 EXPECT_EQ(service->Init(), 0);
752
753 uint64_t contextId = 653215;
754 EXPECT_EQ(service->CancelIdentification(contextId), 10006);
755 }
756
757 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_002, TestSize.Level0)
758 {
759 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
760 EXPECT_NE(service, nullptr);
761
762 EXPECT_EQ(service->Init(), 0);
763
764 int32_t userId = 314265;
765 std::vector<uint8_t> challenge;
766 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
767
768 EnrollResultTest enrollPinResultTest = {};
769 std::vector<uint8_t> authToken;
770 DoOnceEnroll(service, userId, PIN, authToken, enrollPinResultTest);
771 EXPECT_EQ(enrollPinResultTest.result, 0);
772
773 AuthResultTest authResultTest = {};
774 DoOnceAuth(service, userId, PIN, challenge, authResultTest);
775 EXPECT_EQ(authResultTest.result, 0);
776
777 EnrollResultTest enrollFaceResultTest = {};
778 DoOnceEnroll(service, userId, FACE, authResultTest.token, enrollFaceResultTest);
779 EXPECT_EQ(enrollFaceResultTest.result, 0);
780
781 uint64_t contextId = 623159;
782 AuthType authType = FACE;
783 uint32_t executorSensorHint = 0;
784 ScheduleInfo scheduleInfo = {};
785 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
786
787 EXPECT_EQ(service->CancelIdentification(contextId), 0);
788
789 std::vector<CredentialInfo> deletedCredInfos;
790 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
791 EXPECT_TRUE(!deletedCredInfos.empty());
792
793 EXPECT_EQ(service->DeleteExecutor(enrollPinResultTest.executorIndex), 0);
794 EXPECT_EQ(service->DeleteExecutor(enrollFaceResultTest.executorIndex), 0);
795 EXPECT_EQ(service->CloseSession(userId), 0);
796 }
797
798 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_001, TestSize.Level0)
799 {
800 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
801 EXPECT_NE(service, nullptr);
802
803 EXPECT_EQ(service->Init(), 0);
804
805 int32_t userId = 635648;
806 AuthType authType = PIN;
807 std::vector<CredentialInfo> credInfos;
808
809 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
810 EXPECT_TRUE(credInfos.empty());
811 }
812
813 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_002, TestSize.Level0)
814 {
815 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
816 EXPECT_NE(service, nullptr);
817
818 EXPECT_EQ(service->Init(), 0);
819
820 int32_t userId = 635648;
821 AuthType authType = PIN;
822 std::vector<uint8_t> challenge;
823 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
824
825 std::vector<uint8_t> authToken;
826 EnrollResultTest enrollResultTest = {};
827 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
828 EXPECT_EQ(enrollResultTest.result, 0);
829
830 std::vector<CredentialInfo> credInfos;
831 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
832 EXPECT_TRUE(!credInfos.empty());
833
834 std::vector<CredentialInfo> deletedCredInfos;
835 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
836 EXPECT_TRUE(!deletedCredInfos.empty());
837
838 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
839 EXPECT_EQ(service->CloseSession(userId), 0);
840 }
841
842 HWTEST_F(UserAuthInterfaceServiceTest, TestGetUserInfo_001, TestSize.Level0)
843 {
844 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
845 EXPECT_NE(service, nullptr);
846
847 EXPECT_EQ(service->Init(), 0);
848
849 int32_t userId = 635648;
850 AuthType authType = PIN;
851 std::vector<uint8_t> challenge;
852 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
853
854 std::vector<uint8_t> authToken;
855 EnrollResultTest enrollResultTest = {};
856 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
857 EXPECT_EQ(enrollResultTest.result, 0);
858
859 uint64_t secureUid = 0;
860 PinSubType subType = PIN_SIX;
861 std::vector<EnrolledInfo> enrolledInfos;
862 EXPECT_EQ(service->GetUserInfo(userId, secureUid, subType, enrolledInfos), 0);
863 EXPECT_TRUE(!enrolledInfos.empty());
864
865 std::vector<CredentialInfo> deletedCredInfos;
866 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
867 EXPECT_TRUE(!deletedCredInfos.empty());
868
869 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
870 EXPECT_EQ(service->CloseSession(userId), 0);
871 }
872
873 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_001, TestSize.Level0)
874 {
875 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
876 EXPECT_NE(service, nullptr);
877
878 EXPECT_EQ(service->Init(), 0);
879
880 int32_t userId = 321657;
881 std::vector<uint8_t> authToken;
882 std::vector<CredentialInfo> deletedCredInfos;
883 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos), 8);
884
885 authToken.resize(sizeof(UserAuthTokenHal));
886 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos), 10014);
887 }
888
889 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_002, TestSize.Level0)
890 {
891 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
892 EXPECT_NE(service, nullptr);
893
894 EXPECT_EQ(service->Init(), 0);
895
896 int32_t userId = 321657;
897 AuthType authType = PIN;
898 std::vector<uint8_t> challenge;
899 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
900
901 std::vector<uint8_t> authToken;
902 EnrollResultTest enrollResultTest = {};
903 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
904 EXPECT_EQ(enrollResultTest.result, 0);
905
906 AuthResultTest authResultTest = {};
907 DoOnceAuth(service, userId, authType, challenge, authResultTest);
908 EXPECT_EQ(authResultTest.result, 0);
909
910 std::vector<CredentialInfo> deletedCredInfos;
911 EXPECT_EQ(service->DeleteUser(userId, authResultTest.token, deletedCredInfos), 0);
912 EXPECT_TRUE(!deletedCredInfos.empty());
913
914 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
915 EXPECT_EQ(service->CloseSession(userId), 0);
916 }
917
918 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_001, TestSize.Level0)
919 {
920 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
921 EXPECT_NE(service, nullptr);
922
923 EXPECT_EQ(service->Init(), 0);
924
925 int32_t userId = 635678;
926 std::vector<CredentialInfo> deletedCredInfos;
927 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 10006);
928 EXPECT_TRUE(deletedCredInfos.empty());
929 }
930
931 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_002, TestSize.Level0)
932 {
933 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
934 EXPECT_NE(service, nullptr);
935
936 EXPECT_EQ(service->Init(), 0);
937
938 int32_t userId = 635678;
939 AuthType authType = PIN;
940 std::vector<uint8_t> challenge;
941 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
942
943 std::vector<uint8_t> authToken;
944 EnrollResultTest enrollResultTest = {};
945 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
946 EXPECT_EQ(enrollResultTest.result, 0);
947
948 std::vector<CredentialInfo> deletedCredInfos;
949 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
950 EXPECT_TRUE(!deletedCredInfos.empty());
951
952 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
953 EXPECT_EQ(service->CloseSession(userId), 0);
954 }
955
956 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAuthTrustLevel_001, TestSize.Level0)
957 {
958 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
959 EXPECT_NE(service, nullptr);
960
961 EXPECT_EQ(service->Init(), 0);
962
963 int32_t userId = 325614;
964 AuthType authType = PIN;
965 uint32_t authTrustLevel = 0;
966 EXPECT_EQ(service->GetAuthTrustLevel(userId, authType, authTrustLevel), 5);
967 }
968
969 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAuthTrustLevel_002, TestSize.Level0)
970 {
971 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
972 EXPECT_NE(service, nullptr);
973
974 EXPECT_EQ(service->Init(), 0);
975
976 int32_t userId = 325614;
977 AuthType authType = PIN;
978 std::vector<uint8_t> challenge;
979 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
980
981 std::vector<uint8_t> authToken;
982 EnrollResultTest enrollResultTest = {};
983 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
984 EXPECT_EQ(enrollResultTest.result, 0);
985
986 uint32_t authTrustLevel = 0;
987 EXPECT_EQ(service->GetAuthTrustLevel(userId, authType, authTrustLevel), 0);
988
989 std::vector<CredentialInfo> deletedCredInfos;
990 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
991 EXPECT_TRUE(!deletedCredInfos.empty());
992
993 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
994 EXPECT_EQ(service->CloseSession(userId), 0);
995 }
996
997 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdatePin, TestSize.Level0)
998 {
999 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1000 EXPECT_NE(service, nullptr);
1001
1002 EXPECT_EQ(service->Init(), 0);
1003
1004 int32_t userId = 325678;
1005 AuthType authType = PIN;
1006 std::vector<uint8_t> challenge;
1007 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1008
1009 std::vector<uint8_t> authToken;
1010 EnrollResultTest enrollResultTest = {};
1011 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1012 EXPECT_EQ(enrollResultTest.result, 0);
1013
1014 AuthResultTest authResultTest = {};
1015 DoOnceAuth(service, userId, authType, challenge, authResultTest);
1016 EXPECT_EQ(authResultTest.result, 0);
1017
1018 DoOnceEnroll(service, userId, authType, authResultTest.token, enrollResultTest);
1019 EXPECT_EQ(enrollResultTest.result, 0);
1020
1021 std::vector<CredentialInfo> deletedCredInfos;
1022 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1023 EXPECT_TRUE(!deletedCredInfos.empty());
1024
1025 EXPECT_EQ(service->DeleteExecutor(enrollResultTest.executorIndex), 0);
1026 EXPECT_EQ(service->CloseSession(userId), 0);
1027 }
1028 } // namespace V1_0
1029 } // namespace UserAuth
1030 } // namespace HDI
1031 } // namespace OHOS