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::V4_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), 10012);
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 HdiGlobalConfigParam param = {};
666 param.type = ENABLE_STATUS;
667 param.value.enableStatus = true;
668 param.authTypes.push_back(1);
669 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_SUCCESS);
670
671 const std::string deviceUdid = std::string(64, ' ');
672 EXPECT_EQ(service->Init(deviceUdid), 0);
673
674 constexpr int32_t userId = 1;
675
676 std::vector<CredentialInfo> deletedCredInfos;
677 service->EnforceDeleteUser(userId, deletedCredInfos);
678
679 std::vector<uint8_t> challenge;
680 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
681
682 RegisterAllExecutor(service);
683
684 AuthType authType = AuthType::PIN;
685 std::vector<uint8_t> authToken;
686 EnrollResultTest enrollResultTest = {};
687 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
688 EXPECT_EQ(enrollResultTest.result, 0);
689
690 AuthResultTest authResultTest = {};
691 DoOnceAuth(service, userId, authType, challenge, authResultTest);
692 EXPECT_EQ(authResultTest.result, 0);
693
694 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
695 EXPECT_TRUE(!deletedCredInfos.empty());
696
697 DeleteAllExecutor(service);
698 EXPECT_EQ(service->CloseSession(userId), 0);
699 }
700
701 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_001, TestSize.Level0)
702 {
703 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
704 EXPECT_NE(service, nullptr);
705
706 const std::string deviceUdid = std::string(64, ' ');
707 EXPECT_EQ(service->Init(deviceUdid), 0);
708
709 constexpr uint64_t contextId = 256487;
710 EXPECT_EQ(service->CancelAuthentication(contextId), 10006);
711 }
712
713 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelAuthentication_002, TestSize.Level0)
714 {
715 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
716 EXPECT_NE(service, nullptr);
717
718 const std::string deviceUdid = std::string(64, ' ');
719 EXPECT_EQ(service->Init(deviceUdid), 0);
720
721 constexpr int32_t userId = 2;
722 std::vector<uint8_t> challenge;
723 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
724
725 RegisterAllExecutor(service);
726
727 AuthType authType = AuthType::PIN;
728 std::vector<uint8_t> authToken;
729 EnrollResultTest enrollResultTest = {};
730 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
731 EXPECT_EQ(enrollResultTest.result, 0);
732
733 constexpr uint64_t contextId = 653497;
734 AuthParam authParam = {};
735 authParam.baseParam.userId = userId;
736 authParam.baseParam.authTrustLevel = ATL1;
737 authParam.authType = authType;
738 authParam.baseParam.challenge = challenge;
739 std::vector<ScheduleInfo> scheduleInfos;
740 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
741 EXPECT_TRUE(!scheduleInfos.empty());
742
743 EXPECT_EQ(service->CancelAuthentication(contextId), 0);
744
745 std::vector<CredentialInfo> deletedCredInfos;
746 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
747 EXPECT_TRUE(!deletedCredInfos.empty());
748
749 DeleteAllExecutor(service);
750 EXPECT_EQ(service->CloseSession(userId), 0);
751 }
752
753 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_001, TestSize.Level0)
754 {
755 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
756 EXPECT_NE(service, nullptr);
757
758 const std::string deviceUdid = std::string(64, ' ');
759 EXPECT_EQ(service->Init(deviceUdid), 0);
760
761 constexpr uint64_t contextId = 123456;
762 AuthType authType = AuthType::PIN;
763 std::vector<uint8_t> challenge;
764 uint32_t executorSensorHint = 0;
765 ScheduleInfo scheduleInfo = {};
766
767 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 8);
768 }
769
770 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_002, TestSize.Level0)
771 {
772 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
773 EXPECT_NE(service, nullptr);
774
775 const std::string deviceUdid = std::string(64, ' ');
776 EXPECT_EQ(service->Init(deviceUdid), 0);
777
778 constexpr uint64_t contextId = 623159;
779 AuthType authType = AuthType::FACE;
780 std::vector<uint8_t> challenge;
781 uint32_t executorSensorHint = 0;
782 ScheduleInfo scheduleInfo = {};
783
784 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 2);
785 }
786
787 HWTEST_F(UserAuthInterfaceServiceTest, TestBeginIdentification_003, TestSize.Level0)
788 {
789 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
790 EXPECT_NE(service, nullptr);
791
792 const std::string deviceUdid = std::string(64, ' ');
793 EXPECT_EQ(service->Init(deviceUdid), 0);
794
795 ExecutorRegisterInfo info = {};
796 info.authType = AuthType::FACE;
797 info.executorRole = ExecutorRole::ALL_IN_ONE;
798 info.esl = ExecutorSecureLevel::ESL0;
799 EXPECT_EQ(GetExecutorPublicKey(info.publicKey), 0);
800 uint64_t index = 0;
801 std::vector<uint8_t> publicKey;
802 std::vector<uint64_t> templateIds;
803 EXPECT_EQ(service->AddExecutor(info, index, publicKey, templateIds), 0);
804
805 constexpr uint64_t contextId = 623159;
806 AuthType authType = AuthType::FACE;
807 std::vector<uint8_t> challenge;
808 uint32_t executorSensorHint = 0;
809 ScheduleInfo scheduleInfo = {};
810 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
811
812 EXPECT_EQ(service->DeleteExecutor(index), 0);
813 }
814
815 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_001, TestSize.Level0)
816 {
817 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
818 EXPECT_NE(service, nullptr);
819
820 const std::string deviceUdid = std::string(64, ' ');
821 EXPECT_EQ(service->Init(deviceUdid), 0);
822
823 constexpr uint64_t contextId = 621327;
824 std::vector<uint8_t> scheduleResult;
825 IdentifyResultInfo identityResultInfo = {};
826 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo), 8);
827
828 scheduleResult.resize(240);
829 EXPECT_EQ(service->UpdateIdentificationResult(contextId, scheduleResult, identityResultInfo),
830 RESULT_GENERAL_ERROR);
831 }
832
833 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdateIdentificationResult_002, TestSize.Level0)
834 {
835 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
836 EXPECT_NE(service, nullptr);
837
838 const std::string deviceUdid = std::string(64, ' ');
839 EXPECT_EQ(service->Init(deviceUdid), 0);
840
841 constexpr int32_t userId = 3;
842 std::vector<uint8_t> challenge;
843 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
844
845 RegisterAllExecutor(service);
846
847 EnrollResultTest enrollPinResultTest = {};
848 std::vector<uint8_t> authToken;
849 DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
850 EXPECT_EQ(enrollPinResultTest.result, 0);
851
852 AuthResultTest authResultTest = {};
853 DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
854 EXPECT_EQ(authResultTest.result, 0);
855
856 EnrollResultTest enrollFaceResultTest = {};
857 DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
858 EXPECT_EQ(enrollFaceResultTest.result, 0);
859
860 constexpr uint64_t contextId = 623159;
861 AuthType authType = AuthType::FACE;
862 uint32_t executorSensorHint = 0;
863 ScheduleInfo scheduleInfo = {};
864 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
865
866 std::vector<uint8_t> identityScheduleResult;
867 TlvRequiredPara para = {};
868 para.result = 0;
869 para.scheduleId = scheduleInfo.scheduleId;
870 para.subType = 10000;
871 para.templateId = 20;
872 para.remainAttempts = 5;
873 EXPECT_EQ(GetExecutorResultTlv(para, identityScheduleResult), 0);
874 IdentifyResultInfo identityResultInfo = {};
875 EXPECT_EQ(service->UpdateIdentificationResult(contextId, identityScheduleResult, identityResultInfo), 0);
876
877 std::vector<CredentialInfo> deletedCredInfos;
878 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
879 EXPECT_TRUE(!deletedCredInfos.empty());
880
881 DeleteAllExecutor(service);
882 EXPECT_EQ(service->CloseSession(userId), 0);
883 }
884
885 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_001, TestSize.Level0)
886 {
887 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
888 EXPECT_NE(service, nullptr);
889
890 const std::string deviceUdid = std::string(64, ' ');
891 EXPECT_EQ(service->Init(deviceUdid), 0);
892
893 constexpr uint64_t contextId = 653215;
894 EXPECT_EQ(service->CancelIdentification(contextId), 10006);
895 }
896
897 HWTEST_F(UserAuthInterfaceServiceTest, TestCancelIdentification_002, TestSize.Level0)
898 {
899 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
900 EXPECT_NE(service, nullptr);
901
902 const std::string deviceUdid = std::string(64, ' ');
903 EXPECT_EQ(service->Init(deviceUdid), 0);
904
905 constexpr int32_t userId = 4;
906 std::vector<uint8_t> challenge;
907 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
908
909 RegisterAllExecutor(service);
910
911 EnrollResultTest enrollPinResultTest = {};
912 std::vector<uint8_t> authToken;
913 DoOnceEnroll(service, userId, AuthType::PIN, authToken, enrollPinResultTest);
914 EXPECT_EQ(enrollPinResultTest.result, 0);
915
916 AuthResultTest authResultTest = {};
917 DoOnceAuth(service, userId, AuthType::PIN, challenge, authResultTest);
918 EXPECT_EQ(authResultTest.result, 0);
919
920 EnrollResultTest enrollFaceResultTest = {};
921 DoOnceEnroll(service, userId, AuthType::FACE, authResultTest.token, enrollFaceResultTest);
922 EXPECT_EQ(enrollFaceResultTest.result, 0);
923
924 constexpr uint64_t contextId = 623159;
925 AuthType authType = AuthType::FACE;
926 uint32_t executorSensorHint = 0;
927 ScheduleInfo scheduleInfo = {};
928 EXPECT_EQ(service->BeginIdentification(contextId, authType, challenge, executorSensorHint, scheduleInfo), 0);
929
930 EXPECT_EQ(service->CancelIdentification(contextId), 0);
931
932 std::vector<CredentialInfo> deletedCredInfos;
933 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
934 EXPECT_TRUE(!deletedCredInfos.empty());
935
936 DeleteAllExecutor(service);
937 EXPECT_EQ(service->CloseSession(userId), 0);
938 }
939
940 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_001, TestSize.Level0)
941 {
942 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
943 EXPECT_NE(service, nullptr);
944
945 const std::string deviceUdid = std::string(64, ' ');
946 EXPECT_EQ(service->Init(deviceUdid), 0);
947
948 constexpr int32_t userId = 635648;
949 AuthType authType = AuthType::PIN;
950 std::vector<CredentialInfo> credInfos;
951
952 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
953 EXPECT_TRUE(credInfos.empty());
954 }
955
956 HWTEST_F(UserAuthInterfaceServiceTest, TestGetCredential_002, TestSize.Level0)
957 {
958 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
959 EXPECT_NE(service, nullptr);
960
961 const std::string deviceUdid = std::string(64, ' ');
962 EXPECT_EQ(service->Init(deviceUdid), 0);
963
964 constexpr int32_t userId = 635648;
965 AuthType authType = AuthType::PIN;
966 std::vector<uint8_t> challenge;
967 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
968
969 RegisterAllExecutor(service);
970
971 std::vector<uint8_t> authToken;
972 EnrollResultTest enrollResultTest = {};
973 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
974 EXPECT_EQ(enrollResultTest.result, 0);
975
976 std::vector<CredentialInfo> credInfos;
977 EXPECT_EQ(service->GetCredential(userId, authType, credInfos), 0);
978 EXPECT_TRUE(!credInfos.empty());
979
980 std::vector<CredentialInfo> deletedCredInfos;
981 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
982 EXPECT_TRUE(!deletedCredInfos.empty());
983
984 DeleteAllExecutor(service);
985 EXPECT_EQ(service->CloseSession(userId), 0);
986 }
987
988 HWTEST_F(UserAuthInterfaceServiceTest, TestGetUserInfo_001, TestSize.Level0)
989 {
990 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
991 EXPECT_NE(service, nullptr);
992
993 const std::string deviceUdid = std::string(64, ' ');
994 EXPECT_EQ(service->Init(deviceUdid), 0);
995
996 constexpr int32_t userId = 635648;
997 AuthType authType = AuthType::PIN;
998 std::vector<uint8_t> challenge;
999 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1000
1001 RegisterAllExecutor(service);
1002
1003 std::vector<uint8_t> authToken;
1004 EnrollResultTest enrollResultTest = {};
1005 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1006 EXPECT_EQ(enrollResultTest.result, 0);
1007
1008 uint64_t secureUid = 0;
1009 int32_t subType = PinSubType::PIN_SIX;
1010 std::vector<EnrolledInfo> enrolledInfos;
1011 EXPECT_EQ(service->GetUserInfo(userId, secureUid, subType, enrolledInfos), 0);
1012 EXPECT_TRUE(!enrolledInfos.empty());
1013
1014 std::vector<CredentialInfo> deletedCredInfos;
1015 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1016 EXPECT_TRUE(!deletedCredInfos.empty());
1017
1018 DeleteAllExecutor(service);
1019 EXPECT_EQ(service->CloseSession(userId), 0);
1020 }
1021
1022 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_001, TestSize.Level0)
1023 {
1024 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1025 EXPECT_NE(service, nullptr);
1026
1027 const std::string deviceUdid = std::string(64, ' ');
1028 EXPECT_EQ(service->Init(deviceUdid), 0);
1029
1030 constexpr int32_t userId = 321657;
1031 std::vector<uint8_t> authToken;
1032 std::vector<CredentialInfo> deletedCredInfos;
1033 std::vector<uint8_t> rootSecret;
1034 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos, rootSecret), RESULT_VERIFY_TOKEN_FAIL);
1035
1036 authToken.resize(sizeof(UserAuthTokenHal));
1037 EXPECT_EQ(service->DeleteUser(userId, authToken, deletedCredInfos, rootSecret), 10017);
1038 }
1039
1040 HWTEST_F(UserAuthInterfaceServiceTest, TestDeleteUser_002, TestSize.Level0)
1041 {
1042 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1043 EXPECT_NE(service, nullptr);
1044
1045 const std::string deviceUdid = std::string(64, ' ');
1046 EXPECT_EQ(service->Init(deviceUdid), 0);
1047
1048 constexpr int32_t userId = 321657;
1049 AuthType authType = AuthType::PIN;
1050 std::vector<uint8_t> challenge;
1051 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1052
1053 RegisterAllExecutor(service);
1054
1055 std::vector<uint8_t> authToken;
1056 EnrollResultTest enrollResultTest = {};
1057 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1058 EXPECT_EQ(enrollResultTest.result, 0);
1059
1060 AuthResultTest authResultTest = {};
1061 DoOnceAuth(service, userId, authType, challenge, authResultTest);
1062 EXPECT_EQ(authResultTest.result, 0);
1063
1064 std::vector<CredentialInfo> deletedCredInfos;
1065 std::vector<uint8_t> rootSecret;
1066 EXPECT_EQ(service->DeleteUser(userId, authResultTest.token, deletedCredInfos, rootSecret), 0);
1067 EXPECT_TRUE(!deletedCredInfos.empty());
1068
1069 DeleteAllExecutor(service);
1070 EXPECT_EQ(service->CloseSession(userId), 0);
1071 }
1072
1073 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_001, TestSize.Level0)
1074 {
1075 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1076 EXPECT_NE(service, nullptr);
1077
1078 const std::string deviceUdid = std::string(64, ' ');
1079 EXPECT_EQ(service->Init(deviceUdid), 0);
1080
1081 constexpr int32_t userId = 635678;
1082 std::vector<CredentialInfo> deletedCredInfos;
1083 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 10006);
1084 EXPECT_TRUE(deletedCredInfos.empty());
1085 }
1086
1087 HWTEST_F(UserAuthInterfaceServiceTest, TestEnforceDeleteUser_002, TestSize.Level0)
1088 {
1089 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1090 EXPECT_NE(service, nullptr);
1091
1092 const std::string deviceUdid = std::string(64, ' ');
1093 EXPECT_EQ(service->Init(deviceUdid), 0);
1094
1095 constexpr int32_t userId = 635678;
1096 AuthType authType = AuthType::PIN;
1097 std::vector<uint8_t> challenge;
1098 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1099
1100 RegisterAllExecutor(service);
1101
1102 std::vector<uint8_t> authToken;
1103 EnrollResultTest enrollResultTest = {};
1104 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1105 EXPECT_EQ(enrollResultTest.result, 0);
1106
1107 std::vector<CredentialInfo> deletedCredInfos;
1108 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1109 EXPECT_TRUE(!deletedCredInfos.empty());
1110
1111 DeleteAllExecutor(service);
1112 EXPECT_EQ(service->CloseSession(userId), 0);
1113 }
1114
1115 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAvailableStatus_001, TestSize.Level0)
1116 {
1117 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1118 EXPECT_NE(service, nullptr);
1119
1120 const std::string deviceUdid = std::string(64, ' ');
1121 EXPECT_EQ(service->Init(deviceUdid), 0);
1122
1123 constexpr int32_t userId = 325614;
1124 AuthType authType = AuthType::PIN;
1125 uint32_t authTrustLevel = 0;
1126 int32_t checkRet;
1127 EXPECT_EQ(service->GetAvailableStatus(userId, authType, authTrustLevel, checkRet), RESULT_SUCCESS);
1128 EXPECT_EQ(checkRet, RESULT_TYPE_NOT_SUPPORT);
1129 }
1130
1131 HWTEST_F(UserAuthInterfaceServiceTest, TestGetAvailableStatus_002, TestSize.Level0)
1132 {
1133 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1134 EXPECT_NE(service, nullptr);
1135
1136 const std::string deviceUdid = std::string(64, ' ');
1137 EXPECT_EQ(service->Init(deviceUdid), 0);
1138
1139 constexpr int32_t userId = 325614;
1140 AuthType authType = AuthType::PIN;
1141 std::vector<uint8_t> challenge;
1142 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1143
1144 RegisterAllExecutor(service);
1145
1146 std::vector<uint8_t> authToken;
1147 EnrollResultTest enrollResultTest = {};
1148 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1149 EXPECT_EQ(enrollResultTest.result, 0);
1150
1151 uint32_t authTrustLevel = 0;
1152 int32_t checkRet;
1153 EXPECT_EQ(service->GetAvailableStatus(userId, authType, authTrustLevel, checkRet), 0);
1154
1155 std::vector<CredentialInfo> deletedCredInfos;
1156 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1157 EXPECT_TRUE(!deletedCredInfos.empty());
1158
1159 DeleteAllExecutor(service);
1160 EXPECT_EQ(service->CloseSession(userId), 0);
1161 }
1162
1163 HWTEST_F(UserAuthInterfaceServiceTest, TestUpdatePin, TestSize.Level0)
1164 {
1165 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1166 EXPECT_NE(service, nullptr);
1167
1168 const std::string deviceUdid = std::string(64, ' ');
1169 EXPECT_EQ(service->Init(deviceUdid), 0);
1170
1171 constexpr int32_t userId = 325678;
1172 AuthType authType = AuthType::PIN;
1173 std::vector<uint8_t> challenge;
1174 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1175
1176 RegisterAllExecutor(service);
1177
1178 std::vector<uint8_t> authToken;
1179 EnrollResultTest enrollResultTest = {};
1180 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1181 EXPECT_EQ(enrollResultTest.result, 0);
1182
1183 AuthResultTest authResultTest = {};
1184 DoOnceAuth(service, userId, authType, challenge, authResultTest);
1185 EXPECT_EQ(authResultTest.result, 0);
1186
1187 DoOnceEnroll(service, userId, authType, authResultTest.token, enrollResultTest);
1188 EXPECT_EQ(enrollResultTest.result, 0);
1189
1190 std::vector<CredentialInfo> deletedCredInfos;
1191 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1192 EXPECT_TRUE(!deletedCredInfos.empty());
1193
1194 DeleteAllExecutor(service);
1195 EXPECT_EQ(service->CloseSession(userId), 0);
1196 }
1197
1198 HWTEST_F(UserAuthInterfaceServiceTest, TestEnrollTwice, TestSize.Level0)
1199 {
1200 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1201 EXPECT_NE(service, nullptr);
1202
1203 const std::string deviceUdid = std::string(64, ' ');
1204 EXPECT_EQ(service->Init(deviceUdid), 0);
1205
1206 constexpr int32_t userId = 363156;
1207 AuthType authType = AuthType::PIN;
1208 std::vector<uint8_t> challenge;
1209 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1210
1211 RegisterAllExecutor(service);
1212
1213 std::vector<uint8_t> authToken;
1214 EnrollResultTest enrollResultTest = {};
1215 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1216 EXPECT_EQ(enrollResultTest.result, 0);
1217
1218 EnrollParam enrollParam = {};
1219 enrollParam.userId = userId;
1220 enrollParam.authType = authType;
1221 ScheduleInfo scheduleInfo = {};
1222 EXPECT_EQ(service->BeginEnrollment(authToken, enrollParam, scheduleInfo), 10018);
1223
1224 std::vector<CredentialInfo> deletedCredInfos;
1225 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1226 EXPECT_TRUE(!deletedCredInfos.empty());
1227
1228 DeleteAllExecutor(service);
1229 EXPECT_EQ(service->CloseSession(userId), 0);
1230 }
1231
1232 HWTEST_F(UserAuthInterfaceServiceTest, TestInitTwice, TestSize.Level0)
1233 {
1234 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1235 EXPECT_NE(service, nullptr);
1236
1237 const std::string deviceUdid = std::string(64, ' ');
1238 EXPECT_EQ(service->Init(deviceUdid), 0);
1239
1240 constexpr int32_t userId = 368635;
1241 AuthType authType = AuthType::PIN;
1242 std::vector<uint8_t> challenge;
1243 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1244
1245 RegisterAllExecutor(service);
1246
1247 std::vector<uint8_t> authToken;
1248 EnrollResultTest enrollResultTest = {};
1249 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1250 EXPECT_EQ(enrollResultTest.result, 0);
1251
1252 EXPECT_EQ(service->Init(deviceUdid), 0);
1253
1254 std::vector<CredentialInfo> deletedCredInfos;
1255 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1256 EXPECT_TRUE(!deletedCredInfos.empty());
1257
1258 EXPECT_EQ(service->CloseSession(userId), 0);
1259 }
1260
1261 HWTEST_F(UserAuthInterfaceServiceTest, TestAuthLock, TestSize.Level0)
1262 {
1263 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1264 EXPECT_NE(service, nullptr);
1265
1266 const std::string deviceUdid = std::string(64, ' ');
1267 EXPECT_EQ(service->Init(deviceUdid), 0);
1268
1269 constexpr int32_t userId = 365861;
1270 AuthType authType = AuthType::PIN;
1271 std::vector<uint8_t> challenge;
1272 EXPECT_EQ(service->OpenSession(userId, challenge), 0);
1273
1274 RegisterAllExecutor(service);
1275
1276 std::vector<uint8_t> authToken;
1277 EnrollResultTest enrollResultTest = {};
1278 DoOnceEnroll(service, userId, authType, authToken, enrollResultTest);
1279 EXPECT_EQ(enrollResultTest.result, 0);
1280
1281 constexpr uint64_t contextId = 636548;
1282 AuthParam authParam = {};
1283 authParam.baseParam.userId = userId;
1284 authParam.baseParam.authTrustLevel = ATL1;
1285 authParam.authType = authType;
1286 authParam.baseParam.challenge = challenge;
1287 std::vector<ScheduleInfo> scheduleInfos;
1288 EXPECT_EQ(service->BeginAuthentication(contextId, authParam, scheduleInfos), 0);
1289 EXPECT_TRUE(!scheduleInfos.empty());
1290
1291 std::vector<uint8_t> authScheduleResult;
1292 TlvRequiredPara para = {};
1293 para.result = 2;
1294 para.scheduleId = scheduleInfos[0].scheduleId;
1295 para.subType = 10000;
1296 para.templateId = 20;
1297 para.remainAttempts = 0;
1298 EXPECT_EQ(GetExecutorResultTlv(para, authScheduleResult), 0);
1299 AuthResultInfo authResultInfo = {};
1300 EnrolledState enrolledState = {};
1301
1302 EXPECT_EQ(service->UpdateAuthenticationResult(contextId, authScheduleResult, authResultInfo, enrolledState),
1303 RESULT_SUCCESS);
1304
1305 std::vector<CredentialInfo> deletedCredInfos;
1306 EXPECT_EQ(service->EnforceDeleteUser(userId, deletedCredInfos), 0);
1307 EXPECT_TRUE(!deletedCredInfos.empty());
1308
1309 DeleteAllExecutor(service);
1310 EXPECT_EQ(service->CloseSession(userId), 0);
1311 }
1312
1313 HWTEST_F(UserAuthInterfaceServiceTest, TestCheckReuseUnlockResult_001, TestSize.Level0)
1314 {
1315 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1316 EXPECT_NE(service, nullptr);
1317
1318 const std::string deviceUdid = std::string(64, ' ');
1319 EXPECT_EQ(service->Init(deviceUdid), 0);
1320
1321 ReuseUnlockParam param;
1322 ReuseUnlockInfo info;
1323 param.baseParam.userId = 1;
1324 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1325
1326 param.authTypes.push_back(static_cast<AuthType>(PIN));
1327 param.authTypes.push_back(static_cast<AuthType>(FACE));
1328 param.authTypes.push_back(static_cast<AuthType>(FINGERPRINT));
1329 param.authTypes.push_back(static_cast<AuthType>(0));
1330 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1331 param.authTypes.pop_back();
1332 param.reuseUnlockResultDuration = 0;
1333 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1334 param.reuseUnlockResultDuration = 6 * 60 *1000;
1335 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1336 param.reuseUnlockResultDuration = 5 * 60 *1000;
1337 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1338 param.reuseUnlockResultMode = 0;
1339 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_BAD_PARAM);
1340 param.reuseUnlockResultMode = 1;
1341 EXPECT_EQ(service->CheckReuseUnlockResult(param, info), RESULT_GENERAL_ERROR);
1342 }
1343
1344 HWTEST_F(UserAuthInterfaceServiceTest, TestSetGlobalConfigParam_001, TestSize.Level0)
1345 {
1346 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1347 EXPECT_NE(service, nullptr);
1348
1349 const std::string deviceUdid = std::string(64, ' ');
1350 EXPECT_EQ(service->Init(deviceUdid), 0);
1351
1352 HdiGlobalConfigParam param = {};
1353 param.type = 0;
1354 param.value.pinExpiredPeriod = 0;
1355 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_BAD_PARAM);
1356
1357 param.type = PIN_EXPIRED_PERIOD;
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.value.pinExpiredPeriod = 1;
1362 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_SUCCESS);
1363
1364 param.authTypes.clear();
1365 param.type = ENABLE_STATUS;
1366 param.value.enableStatus = true;
1367 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_BAD_PARAM);
1368 param.authTypes.push_back(1);
1369 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_SUCCESS);
1370 param.authTypes.push_back(2);
1371 param.authTypes.push_back(4);
1372 param.authTypes.push_back(4);
1373 param.authTypes.push_back(8);
1374 param.authTypes.push_back(16);
1375 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_BAD_PARAM);
1376
1377 for (uint32_t i = 0; i <= MAX_USER; i++) {
1378 param.userIds.push_back(i);
1379 }
1380 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_BAD_PARAM);
1381
1382 param.authTypes.clear();
1383 param.userIds.clear();
1384 param.type = PIN_EXPIRED_PERIOD;
1385 param.authTypes.push_back(1);
1386 param.value.pinExpiredPeriod = NO_CHECK_PIN_EXPIRED_PERIOD;
1387 EXPECT_EQ(service->SetGlobalConfigParam(param), RESULT_SUCCESS);
1388 }
1389
1390 HWTEST_F(UserAuthInterfaceServiceTest, TestVerifyAuthToken_001, TestSize.Level0)
1391 {
1392 auto service = UserIam::Common::MakeShared<UserAuthInterfaceService>();
1393 EXPECT_NE(service, nullptr);
1394
1395 const std::string deviceUdid = std::string(64, ' ');
1396 EXPECT_EQ(service->Init(deviceUdid), 0);
1397
1398 constexpr uint64_t allowableDuration = 1000;
1399 std::vector<uint8_t> tokenIn = {};
1400 HdiUserAuthTokenPlain tokenPlainOut = {};
1401 std::vector<uint8_t> rootSecret = {};
1402 EXPECT_EQ(service->VerifyAuthToken(tokenIn, allowableDuration, tokenPlainOut, rootSecret),
1403 RESULT_BAD_PARAM);
1404 tokenIn.resize(sizeof(UserAuthTokenHal));
1405 EXPECT_EQ(service->VerifyAuthToken(tokenIn, allowableDuration, tokenPlainOut, rootSecret),
1406 INNER_RESULT_AUTH_TOKEN_EXPIRED);
1407 }
1408 } // namespace UserAuth
1409 } // namespace HDI
1410 } // namespace OHOS