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