1 /*
2 * Copyright (C) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "user_auth_service_test.h"
17
18 #include <future>
19
20 #include "iam_common_defines.h"
21 #include "iam_ptr.h"
22
23 #include "executor_messenger_service.h"
24 #include "mock_event_listener.h"
25 #include "mock_context.h"
26 #include "mock_iuser_auth_interface.h"
27 #include "mock_ipc_common.h"
28 #include "mock_modal_callback.h"
29 #include "mock_user_access_ctrl_callback.h"
30 #include "mock_user_auth_callback.h"
31 #include "mock_user_auth_service.h"
32 #include "mock_resource_node.h"
33 #include "mock_widget_callback_interface.h"
34 #include "resource_node_pool.h"
35 #include "user_auth_service.h"
36
37 namespace OHOS {
38 namespace UserIam {
39 namespace UserAuth {
40 using namespace testing;
41 using namespace testing::ext;
42
InitIpcAuthParamInner(IpcAuthParamInner & authParam,std::vector<uint8_t> & challenge,std::vector<int32_t> & authTypes,int32_t authTrustLevel)43 static void InitIpcAuthParamInner(IpcAuthParamInner &authParam,
44 std::vector<uint8_t> &challenge, std::vector<int32_t> &authTypes, int32_t authTrustLevel)
45 {
46 authParam.challenge = challenge;
47 authParam.authTypes = authTypes;
48 authParam.authTrustLevel = authTrustLevel;
49 }
50
InitIpcWidgetParamInner(IpcWidgetParamInner & widgetParam,const std::string & title,const std::string & navigationButtonText,int32_t windowMode)51 static void InitIpcWidgetParamInner(IpcWidgetParamInner &widgetParam,
52 const std::string &title, const std::string &navigationButtonText, int32_t windowMode)
53 {
54 widgetParam.title = title;
55 widgetParam.navigationButtonText = navigationButtonText;
56 widgetParam.windowMode = windowMode;
57 }
58
59 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_001, TestSize.Level0)
60 {
61 UserAuthService service;
62 int32_t apiVersion = 10;
63 std::vector<uint8_t> challenge = {1, 2, 3, 4};
64 std::vector<int32_t> authTypes = {FACE};
65 IpcAuthParamInner authParam;
66 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
67 IpcWidgetParamInner widgetParam;
68 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "确定", 0);
69 sptr<IIamCallback> testUserAuthCallback(nullptr);
70 sptr<IModalCallback> testModalCallback(nullptr);
71 uint64_t contextId = 0;
72 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testUserAuthCallback, testModalCallback,
73 contextId);
74 EXPECT_EQ(ret, GENERAL_ERROR);
75 EXPECT_EQ(contextId, (uint64_t)0);
76 }
77
78 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_002, TestSize.Level0)
79 {
80 UserAuthService service;
81 int32_t apiVersion = 10;
82 std::vector<uint8_t> challenge = {1, 2, 3, 4};
83 std::vector<int32_t> authTypes = {FACE};
84 IpcAuthParamInner authParam;
85 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
86 IpcWidgetParamInner widgetParam;
87 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
88 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
89 EXPECT_NE(testCallback, nullptr);
90 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
91 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
92 sptr<IIamCallback> callbackInterface = testCallback;
93 sptr<IModalCallback> testModalCallback(nullptr);
94 uint64_t contextId = 0;
95 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
96 contextId);
97 EXPECT_EQ(ret, INVALID_PARAMETERS);
98 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
99 IpcCommon::DeleteAllPermission();
100 }
101
102 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_003, TestSize.Level0)
103 {
104 UserAuthService service;
105 int32_t apiVersion = 10;
106 std::vector<uint8_t> challenge = {1, 2, 3, 4};
107 std::vector<int32_t> authTypes = {FACE};
108 IpcAuthParamInner authParam;
109 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
110 IpcWidgetParamInner widgetParam;
111 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
112 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
113 EXPECT_NE(testCallback, nullptr);
114 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
115 IpcCommon::AddPermission(IS_SYSTEM_APP);
116 sptr<IIamCallback> callbackInterface = testCallback;
117 sptr<IModalCallback> testModalCallback(nullptr);
118 uint64_t contextId = 0;
119 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
120 contextId);
121 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
122 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
123 IpcCommon::DeleteAllPermission();
124 }
125
126 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_004, TestSize.Level0)
127 {
128 UserAuthService service;
129 int32_t apiVersion = 10;
130 std::vector<uint8_t> challenge = {1, 2, 3, 4};
131 std::vector<int32_t> authTypes = {FACE};
132 IpcAuthParamInner authParam;
133 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
134 IpcWidgetParamInner widgetParam;
135 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
136 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
137 EXPECT_NE(testCallback, nullptr);
138 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
139 IpcCommon::AddPermission(USE_USER_IDM_PERMISSION);
140 sptr<IIamCallback> callbackInterface = testCallback;
141 sptr<IModalCallback> testModalCallback(nullptr);
142 uint64_t contextId = 0;
143 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
144 contextId);
145 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
146 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
147 IpcCommon::DeleteAllPermission();
148 }
149
150 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_005, TestSize.Level0)
151 {
152 UserAuthService service;
153 int32_t apiVersion = 10;
154 std::vector<uint8_t> challenge = {1, 2, 3, 4};
155 std::vector<int32_t> authTypes = {FACE};
156 IpcAuthParamInner authParam;
157 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
158 IpcWidgetParamInner widgetParam;
159 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
160 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
161 EXPECT_NE(testCallback, nullptr);
162 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
163 IpcCommon::AddPermission(IS_SYSTEM_APP);
164 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
165 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
166 EXPECT_NE(mockHdi, nullptr);
167 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
168 sptr<IIamCallback> callbackInterface = testCallback;
169 sptr<IModalCallback> testModalCallback(nullptr);
170 uint64_t contextId = 0;
171 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
172 contextId);
173 EXPECT_EQ(ret, FAIL);
174 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
175 service.CancelAuthOrIdentify(contextId, 0);
176 IpcCommon::DeleteAllPermission();
177 }
178
179 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_006, TestSize.Level0)
180 {
181 UserAuthService service;
182 int32_t apiVersion = 10;
183 std::vector<uint8_t> challenge = {1, 2, 3, 4};
184 std::vector<int32_t> authTypes = {FACE};
185 IpcAuthParamInner authParam;
186 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
187 IpcWidgetParamInner widgetParam;
188 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
189 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
190 EXPECT_NE(mockHdi, nullptr);
191 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
192 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
193 EXPECT_NE(testCallback, nullptr);
194 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
195 IpcCommon::AddPermission(IS_SYSTEM_APP);
196 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
197 sptr<IIamCallback> callbackInterface = testCallback;
198 sptr<IModalCallback> testModalCallback(nullptr);
199 uint64_t contextId = 0;
200 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
201 contextId);
202 EXPECT_EQ(ret, FAIL);
203 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
204 service.CancelAuthOrIdentify(contextId, 0);
205 IpcCommon::DeleteAllPermission();
206 }
207
208 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_007, TestSize.Level0)
209 {
210 UserAuthService service;
211 int32_t apiVersion = 10;
212 std::vector<uint8_t> challenge = {1, 2, 3, 4};
213 std::vector<int32_t> authTypes;
214 IpcAuthParamInner authParam;
215 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
216 IpcWidgetParamInner widgetParam;
217 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
218 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
219 EXPECT_NE(testCallback, nullptr);
220 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(2);
221 int32_t userId = 1;
222 IpcCommon::GetCallingUserId(service, userId);
223 IpcCommon::AddPermission(IS_SYSTEM_APP);
224 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
225 sptr<IIamCallback> callbackInterface = testCallback;
226 sptr<IModalCallback> testModalCallback(nullptr);
227 uint64_t contextId = 0;
228 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
229 contextId);
230 EXPECT_EQ(ret, INVALID_PARAMETERS);
231 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
232
233 authParam.authTypes.push_back(FACE);
234 authParam.authTypes.push_back(FACE);
235 authParam.authTypes.push_back(FACE);
236 authParam.authTypes.push_back(FACE);
237 ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
238 contextId);
239 EXPECT_EQ(ret, INVALID_PARAMETERS);
240 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
241 IpcCommon::DeleteAllPermission();
242 }
243
244 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_008, TestSize.Level0)
245 {
246 UserAuthService service;
247 int32_t apiVersion = 10;
248 std::vector<uint8_t> challenge = {1, 2, 3, 4};
249 std::vector<int32_t> authTypes = {5};
250 IpcAuthParamInner authParam;
251 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
252 IpcWidgetParamInner widgetParam;
253 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
254 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
255 EXPECT_NE(testCallback, nullptr);
256 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
257 IpcCommon::AddPermission(IS_SYSTEM_APP);
258 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
259 sptr<IIamCallback> callbackInterface = testCallback;
260 sptr<IModalCallback> testModalCallback(nullptr);
261 uint64_t contextId = 0;
262 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
263 contextId);
264 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
265 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
266 IpcCommon::DeleteAllPermission();
267 }
268
269 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_009, TestSize.Level0)
270 {
271 UserAuthService service;
272 int32_t apiVersion = 10;
273 std::vector<uint8_t> challenge = {1, 2, 3, 4};
274 std::vector<int32_t> authTypes = {ALL};
275 IpcAuthParamInner authParam;
276 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
277 IpcWidgetParamInner widgetParam;
278 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
279 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
280 EXPECT_NE(testCallback, nullptr);
281 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
282 IpcCommon::AddPermission(IS_SYSTEM_APP);
283 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
284 sptr<IIamCallback> callbackInterface = testCallback;
285 sptr<IModalCallback> testModalCallback(nullptr);
286 uint64_t contextId = 0;
287 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
288 contextId);
289 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
290 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
291 IpcCommon::DeleteAllPermission();
292 }
293
294 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_010, TestSize.Level0)
295 {
296 UserAuthService service;
297 int32_t apiVersion = 10;
298 std::vector<uint8_t> challenge = {1, 2, 3, 4};
299 std::vector<int32_t> authTypes = {PIN};
300 IpcAuthParamInner authParam;
301 InitIpcAuthParamInner(authParam, challenge, authTypes, 50000);
302 IpcWidgetParamInner widgetParam;
303 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
304 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
305 EXPECT_NE(testCallback, nullptr);
306 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
307 IpcCommon::AddPermission(IS_SYSTEM_APP);
308 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
309 sptr<IIamCallback> callbackInterface = testCallback;
310 sptr<IModalCallback> testModalCallback(nullptr);
311 uint64_t contextId = 0;
312 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
313 contextId);
314 EXPECT_EQ(ret, TRUST_LEVEL_NOT_SUPPORT);
315 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
316 IpcCommon::DeleteAllPermission();
317 }
318
319 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_011, TestSize.Level0)
320 {
321 UserAuthService service;
322 int32_t apiVersion = 10;
323 std::vector<uint8_t> challenge = {1, 2, 3, 4};
324 std::vector<int32_t> authTypes = {PIN};
325 IpcAuthParamInner authParam;
326 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL1);
327 IpcWidgetParamInner widgetParam;
328 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
329 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
330 EXPECT_NE(testCallback, nullptr);
331 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
332 IpcCommon::AddPermission(IS_SYSTEM_APP);
333 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
334 sptr<IIamCallback> callbackInterface = testCallback;
335 sptr<IModalCallback> testModalCallback(nullptr);
336 uint64_t contextId = 0;
337 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
338 contextId);
339 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
340 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
341 IpcCommon::DeleteAllPermission();
342 }
343
344 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_012, TestSize.Level0)
345 {
346 UserAuthService service;
347 int32_t apiVersion = 10;
348 std::vector<uint8_t> challenge = {1, 2, 3, 4};
349 std::vector<int32_t> authTypes = {PIN};
350 IpcAuthParamInner authParam;
351 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL1);
352 IpcWidgetParamInner widgetParam;
353 InitIpcWidgetParamInner(widgetParam, "WidgetParamTitle", "", WindowModeType::UNKNOWN_WINDOW_MODE);
354 sptr<MockUserAuthCallback> testCallback(new (std::nothrow) MockUserAuthCallback);
355 EXPECT_NE(testCallback, nullptr);
356 EXPECT_CALL(*testCallback, OnResult(_, _)).Times(1);
357 IpcCommon::AddPermission(IS_SYSTEM_APP);
358 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
359 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
360 EXPECT_NE(mockHdi, nullptr);
361 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
362 sptr<IIamCallback> callbackInterface = testCallback;
363 sptr<IModalCallback> testModalCallback(nullptr);
364 uint64_t contextId = 0;
365 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, callbackInterface, testModalCallback,
366 contextId);
367 EXPECT_EQ(ret, FAIL);
368 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
369 service.CancelAuthOrIdentify(contextId, 0);
370 IpcCommon::DeleteAllPermission();
371 }
372
373 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_013, TestSize.Level0)
374 {
375 UserAuthService service;
376 int32_t apiVersion = 10;
377 std::vector<uint8_t> challenge = {1, 2, 3, 4};
378 std::vector<int32_t> authTypes = {FACE};
379 IpcAuthParamInner authParam;
380 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
381 IpcWidgetParamInner widgetParam;
382 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
383 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
384 EXPECT_NE(testCallback, nullptr);
385 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
386 EXPECT_NE(tempCallback, nullptr);
387 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
388 IpcCommon::AddPermission(IS_SYSTEM_APP);
389 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
390 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
391 EXPECT_NE(mockHdi, nullptr);
392 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
393 sptr<IModalCallback> modalCallback = new MockModalCallback();
394 EXPECT_NE(modalCallback, nullptr);
395 auto *testModalCallback = static_cast<MockModalCallback *>(modalCallback.GetRefPtr());
396 EXPECT_NE(testModalCallback, nullptr);
397 EXPECT_CALL(*testModalCallback, SendCommand(_, _)).Times(0);
398 uint64_t contextId = 0;
399 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, modalCallback,
400 contextId);
401 EXPECT_EQ(ret, FAIL);
402 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
403 IpcCommon::DeleteAllPermission();
404 }
405
406 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_014, TestSize.Level0)
407 {
408 UserAuthService service;
409 int32_t apiVersion = 10;
410 std::vector<uint8_t> challenge = {1, 2, 3, 4};
411 std::vector<int32_t> authTypes = {FACE};
412 IpcAuthParamInner authParam;
413 InitIpcAuthParamInner(authParam, challenge, authTypes, 50000);
414 IpcWidgetParamInner widgetParam;
415 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
416 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
417 EXPECT_NE(testCallback, nullptr);
418 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
419 EXPECT_NE(tempCallback, nullptr);
420 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
421 IpcCommon::AddPermission(IS_SYSTEM_APP);
422 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
423 sptr<IModalCallback> testModalCallback(nullptr);
424 uint64_t contextId = 0;
425 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback,
426 contextId);
427 EXPECT_EQ(ret, TRUST_LEVEL_NOT_SUPPORT);
428 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
429 IpcCommon::DeleteAllPermission();
430 }
431
432 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_015, TestSize.Level0)
433 {
434 UserAuthService service;
435 int32_t apiVersion = 10;
436 std::vector<uint8_t> challenge = {1, 2, 3, 4};
437 std::vector<int32_t> authTypes = {FINGERPRINT};
438 IpcAuthParamInner authParam;
439 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
440 IpcWidgetParamInner widgetParam;
441 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
442 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
443 EXPECT_NE(testCallback, nullptr);
444 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
445 EXPECT_NE(tempCallback, nullptr);
446 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
447 IpcCommon::AddPermission(IS_SYSTEM_APP);
448 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
449 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
450 EXPECT_NE(mockHdi, nullptr);
451 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
452 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760102(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 453 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
454 HdiCredentialInfo tempInfo = {
455 .credentialId = 1,
456 .executorIndex = 0,
457 .templateId = 3,
458 .authType = static_cast<HdiAuthType>(1),
459 .executorMatcher = 2,
460 .executorSensorHint = 3,
461 };
462 infos.push_back(tempInfo);
463 return HDF_SUCCESS;
464 }
465 );
466 ResourceNodePool::Instance().Insert(nullptr);
467 sptr<IModalCallback> testModalCallback(nullptr);
468 uint64_t contextId = 0;
469 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback,
470 contextId);
471 EXPECT_EQ(ret, FAIL);
472 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
473 service.CancelAuthOrIdentify(contextId, 0);
474 IpcCommon::DeleteAllPermission();
475 }
476
477 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_016, TestSize.Level0)
478 {
479 UserAuthService service;
480 int32_t apiVersion = 10;
481 std::vector<uint8_t> challenge = {1};
482 std::vector<int32_t> authTypes = {PIN};
483 IpcAuthParamInner authParam;
484 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
485 IpcWidgetParamInner widgetParam;
486 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
487 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
488 EXPECT_NE(testCallback, nullptr);
489 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
490 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
491 IpcCommon::AddPermission(IS_SYSTEM_APP);
492 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
493 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
494 EXPECT_NE(mockHdi, nullptr);
495 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
496 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760202(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 497 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
498 HdiCredentialInfo tempInfo = {
499 .credentialId = 1,
500 .executorIndex = 0,
501 .templateId = 3,
502 .authType = static_cast<HdiAuthType>(1),
503 .executorMatcher = 2,
504 .executorSensorHint = 3,
505 };
506 infos.push_back(tempInfo);
507 return HDF_SUCCESS;
508 }
509 );
510 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
511 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
512 ResourceNodePool::Instance().Insert(resourceNode1);
__anona135bf760302(const Attributes &condition, Attributes &values) 513 ON_CALL(*resourceNode1, GetProperty).WillByDefault([](const Attributes &condition, Attributes &values) {
514 return SUCCESS;
515 }
516 );
517 sptr<IModalCallback> testModalCallback(nullptr);
518 uint64_t contextId = 0;
519 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
520 EXPECT_EQ(ret, FAIL);
521 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
522 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
523 service.CancelAuthOrIdentify(contextId, 0);
524 IpcCommon::DeleteAllPermission();
525 }
526
527 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0017, TestSize.Level0)
528 {
529 UserAuthService service;
530 int32_t apiVersion = 10;
531 std::vector<uint8_t> challenge = {1};
532 std::vector<int32_t> authTypes = {FINGERPRINT};
533 IpcAuthParamInner authParam;
534 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
535 IpcWidgetParamInner widgetParam;
536 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
537 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
538 EXPECT_NE(testCallback, nullptr);
539 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
540 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
541 IpcCommon::AddPermission(IS_SYSTEM_APP);
542 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
543 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
544 EXPECT_NE(mockHdi, nullptr);
545 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
546 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760402(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 547 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
548 HdiCredentialInfo tempInfo = {
549 .credentialId = 1,
550 .executorIndex = 0,
551 .templateId = 3,
552 .authType = static_cast<HdiAuthType>(1),
553 .executorMatcher = 2,
554 .executorSensorHint = 3,
555 };
556 infos.push_back(tempInfo);
557 return HDF_SUCCESS;
558 }
559 );
560 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
561 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
562 ResourceNodePool::Instance().Insert(resourceNode1);
__anona135bf760502(const Attributes &condition, Attributes &values) 563 ON_CALL(*resourceNode1, GetProperty).WillByDefault([](const Attributes &condition, Attributes &values) {
564 values.SetStringValue(Attributes::ATTR_PIN_SUB_TYPE, "test");
565 return SUCCESS;
566 }
567 );
568 sptr<IModalCallback> testModalCallback(nullptr);
569 uint64_t contextId = 0;
570 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
571 EXPECT_EQ(ret, FAIL);
572 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
573 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
574 service.CancelAuthOrIdentify(contextId, 0);
575 IpcCommon::DeleteAllPermission();
576 }
577
578 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0018, TestSize.Level0)
579 {
580 UserAuthService service;
581 int32_t apiVersion = 10;
582 std::vector<uint8_t> challenge = {1};
583 std::vector<int32_t> authTypes = {FINGERPRINT};
584 IpcAuthParamInner authParam;
585 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
586 IpcWidgetParamInner widgetParam;
587 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
588 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
589 EXPECT_NE(testCallback, nullptr);
590 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
591 EXPECT_NE(tempCallback, nullptr);
592 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
593 IpcCommon::AddPermission(IS_SYSTEM_APP);
594 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
595 int32_t acquire = 20;
596 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
597 EXPECT_NE(mockHdi, nullptr);
598 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
599 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760602(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 600 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
601 HdiCredentialInfo tempInfo = {
602 .credentialId = 1,
603 .executorIndex = 0,
604 .templateId = 3,
605 .authType = static_cast<HdiAuthType>(1),
606 };
607 infos.push_back(tempInfo);
608 return HDF_SUCCESS;
609 }
610 );
611 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
612 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
613 ResourceNodePool::Instance().Insert(resourceNode1);
__anona135bf760702(const Attributes &condition, Attributes &values) 614 ON_CALL(*resourceNode1, GetProperty).WillByDefault([acquire](const Attributes &condition, Attributes &values) {
615 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
616 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
617 return SUCCESS;
618 }
619 );
620 sptr<IModalCallback> testModalCallback(nullptr);
621 uint64_t contextId = 0;
622 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
623 EXPECT_EQ(ret, FAIL);
624 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
625 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
626 service.CancelAuthOrIdentify(contextId, 0);
627 IpcCommon::DeleteAllPermission();
628 }
629
630 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0019, TestSize.Level0)
631 {
632 UserAuthService service;
633 int32_t apiVersion = 10;
634 std::vector<uint8_t> challenge = {1};
635 std::vector<int32_t> authTypes = {FINGERPRINT};
636 IpcAuthParamInner authParam;
637 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
638 IpcWidgetParamInner widgetParam;
639 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
640 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
641 auto *tempCallback = static_cast<MockUserAuthCallback *>(testCallback.GetRefPtr());
642 EXPECT_NE(tempCallback, nullptr);
643 EXPECT_CALL(*tempCallback, OnResult(_, _)).Times(1);
644 IpcCommon::AddPermission(IS_SYSTEM_APP);
645 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
646 int32_t acquire = 20;
647 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
648 EXPECT_NE(mockHdi, nullptr);
649 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillRepeatedly(Return(FAIL));
650 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760802(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 651 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
652 HdiCredentialInfo tempInfo = {
653 .credentialId = 1,
654 .executorIndex = 0,
655 .templateId = 3,
656 .authType = static_cast<HdiAuthType>(1),
657 };
658 infos.push_back(tempInfo);
659 return HDF_SUCCESS;
660 }
661 );
662 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
663 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
664 ResourceNodePool::Instance().Insert(resourceNode1);
__anona135bf760902(const Attributes &condition, Attributes &values) 665 ON_CALL(*resourceNode1, GetProperty).WillByDefault([acquire](const Attributes &condition, Attributes &values) {
666 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
667 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
668 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
669 return SUCCESS;
670 }
671 );
672 sptr<IModalCallback> testModalCallback(nullptr);
673 uint64_t contextId = 0;
674 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
675 EXPECT_EQ(ret, FAIL);
676 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
677 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
678 service.CancelAuthOrIdentify(contextId, 0);
679 IpcCommon::DeleteAllPermission();
680 }
681
682 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0020, TestSize.Level0)
683 {
684 UserAuthService service;
685 int32_t apiVersion = 10;
686 std::vector<uint8_t> challenge = {1};
687 std::vector<int32_t> authTypes = {PIN};
688 IpcAuthParamInner authParam;
689 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
690 IpcWidgetParamInner widgetParam;
691 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
692 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
693 EXPECT_NE(testCallback, nullptr);
694 IpcCommon::AddPermission(IS_SYSTEM_APP);
695 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
696 int32_t acquire = 20;
697 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
698 EXPECT_NE(mockHdi, nullptr);
699 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760a02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 700 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
701 HdiCredentialInfo tempInfo = {
702 .credentialId = 1,
703 .executorIndex = 0,
704 .templateId = 3,
705 .authType = static_cast<HdiAuthType>(0),
706 };
707 infos.push_back(tempInfo);
708 return HDF_SUCCESS;
709 }
710 );
711 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
712 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
713 ResourceNodePool::Instance().Insert(resourceNode1);
714 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anona135bf760b02(const Attributes &condition, Attributes &values) 715 [acquire](const Attributes &condition, Attributes &values) {
716 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
717 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
718 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
719 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
720 return SUCCESS;
721 }
722 );
723 sptr<IModalCallback> testModalCallback(nullptr);
724 uint64_t contextId = 0;
725 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
726 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
727 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
728 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
729 IpcCommon::DeleteAllPermission();
730 }
731
732 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_0021, TestSize.Level0)
733 {
734 UserAuthService service;
735 int32_t apiVersion = 10;
736 std::vector<uint8_t> challenge = {1};
737 std::vector<int32_t> authTypes = {ALL};
738 IpcAuthParamInner authParam;
739 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
740 IpcWidgetParamInner widgetParam;
741 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
742 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
743 EXPECT_NE(testCallback, nullptr);
744 IpcCommon::AddPermission(IS_SYSTEM_APP);
745 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
746 int32_t acquire = 20;
747 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
748 EXPECT_NE(mockHdi, nullptr);
749 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760c02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 750 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
751 HdiCredentialInfo tempInfo = {
752 .credentialId = 1,
753 .executorIndex = 0,
754 .templateId = 3,
755 .authType = static_cast<HdiAuthType>(0),
756 };
757 infos.push_back(tempInfo);
758 return HDF_SUCCESS;
759 }
760 );
761 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
762 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
763 ResourceNodePool::Instance().Insert(resourceNode1);
764 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anona135bf760d02(const Attributes &condition, Attributes &values) 765 [acquire](const Attributes &condition, Attributes &values) {
766 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
767 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
768 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
769 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
770 return SUCCESS;
771 }
772 );
773 sptr<IModalCallback> testModalCallback(nullptr);
774 uint64_t contextId = 0;
775 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
776 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
777 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
778 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
779 IpcCommon::DeleteAllPermission();
780 }
781
782 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_022, TestSize.Level0)
783 {
784 UserAuthService service;
785 int32_t apiVersion = 10;
786 std::vector<uint8_t> challenge = {1};
787 std::vector<int32_t> authTypes = {FINGERPRINT};
788 IpcAuthParamInner authParam;
789 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
790 IpcWidgetParamInner widgetParam;
791 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
792 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
793 EXPECT_NE(testCallback, nullptr);
794 IpcCommon::AddPermission(IS_SYSTEM_APP);
795 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
796 int32_t acquire = 20;
797 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
798 EXPECT_NE(mockHdi, nullptr);
799 ON_CALL(*mockHdi, GetCredential).WillByDefault(
__anona135bf760e02(int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) 800 [](int32_t userId, int32_t authType, std::vector<HdiCredentialInfo> &infos) {
801 HdiCredentialInfo tempInfo = {
802 .credentialId = 1,
803 .executorIndex = 0,
804 .templateId = 3,
805 .authType = static_cast<HdiAuthType>(1),
806 };
807 infos.push_back(tempInfo);
808 return HDF_SUCCESS;
809 }
810 );
811 auto resourceNode1 = Common::MakeShared<MockResourceNode>();
812 EXPECT_CALL(*resourceNode1, GetExecutorIndex()).WillRepeatedly(Return(0));
813 ResourceNodePool::Instance().Insert(resourceNode1);
814 ON_CALL(*resourceNode1, GetProperty).WillByDefault(
__anona135bf760f02(const Attributes &condition, Attributes &values) 815 [acquire](const Attributes &condition, Attributes &values) {
816 values.SetInt32Value(Attributes::ATTR_PIN_SUB_TYPE, acquire);
817 values.SetStringValue(Attributes::ATTR_SENSOR_INFO, "test");
818 values.SetInt32Value(Attributes::ATTR_REMAIN_TIMES, acquire);
819 values.SetInt32Value(Attributes::ATTR_FREEZING_TIME, acquire);
820 return SUCCESS;
821 }
822 );
823 sptr<IModalCallback> testModalCallback(nullptr);
824 uint64_t contextId = 0;
825 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
826 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
827 EXPECT_NE(contextId, INVALID_CONTEXT_ID);
828 EXPECT_TRUE(ResourceNodePool::Instance().Delete(0));
829 IpcCommon::DeleteAllPermission();
830 }
831
832 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_023, TestSize.Level0)
833 {
834 UserAuthService service;
835 int32_t apiVersion = 10;
836 std::vector<uint8_t> challenge = {1};
837 std::vector<int32_t> authTypes = {FINGERPRINT};
838 IpcAuthParamInner authParam;
839 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
840 authParam.reuseUnlockResult.isReuse = true;
841 authParam.reuseUnlockResult.reuseMode = AUTH_TYPE_IRRELEVANT;
842 authParam.reuseUnlockResult.reuseDuration = 5 * 60 *1000;
843 IpcWidgetParamInner widgetParam;
844 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::UNKNOWN_WINDOW_MODE);
845 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
846 EXPECT_NE(testCallback, nullptr);
847 IpcCommon::AddPermission(IS_SYSTEM_APP);
848 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
849 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
850 EXPECT_NE(mockHdi, nullptr);
851 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
852 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
853 EXPECT_CALL(*mockHdi, CheckReuseUnlockResult(_, _)).Times(1);
854 ON_CALL(*mockHdi, CheckReuseUnlockResult)
855 .WillByDefault(
__anona135bf761002(const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) 856 [](const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) {
857 static const uint32_t USER_AUTH_TOKEN_LEN = 148;
858 reuseInfo.token.resize(USER_AUTH_TOKEN_LEN);
859 return HDF_SUCCESS;
860 }
861 );
862 sptr<IModalCallback> testModalCallback(nullptr);
863 uint64_t contextId = 0;
864 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
865 EXPECT_EQ(ret, SUCCESS);
866 EXPECT_EQ(contextId, REUSE_AUTH_RESULT_CONTEXT_ID);
867 IpcCommon::DeleteAllPermission();
868 }
869
870 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_024, TestSize.Level0)
871 {
872 UserAuthService service;
873 int32_t apiVersion = 10;
874 std::vector<uint8_t> challenge = {1};
875 std::vector<int32_t> authTypes = {FACE};
876 IpcAuthParamInner authParam;
877 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
878 IpcWidgetParamInner widgetParam;
879 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "确定", WindowModeType::UNKNOWN_WINDOW_MODE);
880 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
881 EXPECT_NE(testCallback, nullptr);
882 IpcCommon::AddPermission(IS_SYSTEM_APP);
883 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
884 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
885 EXPECT_NE(mockHdi, nullptr);
886 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
887 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
888 sptr<IModalCallback> testModalCallback(nullptr);
889 uint64_t contextId = 0;
890 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
891 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
892 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
893 IpcCommon::DeleteAllPermission();
894 }
895
896 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_025, TestSize.Level0)
897 {
898 UserAuthService service;
899 int32_t apiVersion = 10;
900 std::vector<uint8_t> challenge = {1};
901 std::vector<int32_t> authTypes = {FACE};
902 IpcAuthParamInner authParam;
903 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
904 IpcWidgetParamInner widgetParam;
905 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "确定", WindowModeType::UNKNOWN_WINDOW_MODE);
906 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
907 EXPECT_NE(testCallback, nullptr);
908 IpcCommon::AddPermission(IS_SYSTEM_APP);
909 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
910 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
911 EXPECT_NE(mockHdi, nullptr);
912 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
913 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
914 ON_CALL(*mockHdi, GetValidSolution)
915 .WillByDefault(
916 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761102(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 917 std::vector<int32_t>& validTypes) {
918 return PIN_EXPIRED;
919 }
920 );
921 sptr<IModalCallback> testModalCallback(nullptr);
922 uint64_t contextId = 0;
923 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
924 EXPECT_EQ(ret, GENERAL_ERROR);
925 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
926 IpcCommon::DeleteAllPermission();
927 }
928
929 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_026, TestSize.Level0)
930 {
931 UserAuthService service;
932 int32_t apiVersion = 10;
933 std::vector<uint8_t> challenge = {1};
934 std::vector<int32_t> authTypes = {FACE};
935 IpcAuthParamInner authParam;
936 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
937 IpcWidgetParamInner widgetParam;
938 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
939 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
940 EXPECT_NE(testCallback, nullptr);
941 IpcCommon::AddPermission(IS_SYSTEM_APP);
942 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
943 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
944 EXPECT_NE(mockHdi, nullptr);
945 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
946 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
947 ON_CALL(*mockHdi, GetValidSolution)
948 .WillByDefault(
949 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761202(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 950 std::vector<int32_t>& validTypes) {
951 validTypes.clear();
952 validTypes.push_back(AuthType::FACE);
953 return HDF_SUCCESS;
954 }
955 );
956 sptr<IModalCallback> testModalCallback(nullptr);
957 uint64_t contextId = 0;
958 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
959 EXPECT_EQ(ret, INVALID_PARAMETERS);
960 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
961 IpcCommon::DeleteAllPermission();
962 }
963
964 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_027, TestSize.Level0)
965 {
966 UserAuthService service;
967 int32_t apiVersion = 10;
968 std::vector<uint8_t> challenge = {1};
969 std::vector<int32_t> authTypes = {FINGERPRINT};
970 IpcAuthParamInner authParam;
971 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
972 IpcWidgetParamInner widgetParam;
973 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
974 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
975 EXPECT_NE(testCallback, nullptr);
976 IpcCommon::AddPermission(IS_SYSTEM_APP);
977 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
978 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
979 EXPECT_NE(mockHdi, nullptr);
980 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
981 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
982 ON_CALL(*mockHdi, GetValidSolution)
983 .WillByDefault(
984 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761302(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 985 std::vector<int32_t>& validTypes) {
986 validTypes.clear();
987 validTypes.push_back(AuthType::FINGERPRINT);
988 return HDF_SUCCESS;
989 }
990 );
991 sptr<IModalCallback> testModalCallback(nullptr);
992 uint64_t contextId = 0;
993 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
994 EXPECT_EQ(ret, INVALID_PARAMETERS);
995 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
996 IpcCommon::DeleteAllPermission();
997 }
998
999 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_028, TestSize.Level0)
1000 {
1001 UserAuthService service;
1002 int32_t apiVersion = 10;
1003 std::vector<uint8_t> challenge = {1};
1004 std::vector<int32_t> authTypes = {PIN};
1005 IpcAuthParamInner authParam;
1006 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1007 IpcWidgetParamInner widgetParam;
1008 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
1009 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1010 EXPECT_NE(testCallback, nullptr);
1011 IpcCommon::AddPermission(IS_SYSTEM_APP);
1012 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1013 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1014 EXPECT_NE(mockHdi, nullptr);
1015 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1016 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1017 ON_CALL(*mockHdi, GetValidSolution)
1018 .WillByDefault(
1019 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761402(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 1020 std::vector<int32_t>& validTypes) {
1021 validTypes.clear();
1022 validTypes.push_back(AuthType::PIN);
1023 return HDF_SUCCESS;
1024 }
1025 );
1026 sptr<IModalCallback> testModalCallback(nullptr);
1027 uint64_t contextId = 0;
1028 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1029 EXPECT_EQ(ret, GENERAL_ERROR);
1030 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1031 IpcCommon::DeleteAllPermission();
1032 }
1033
1034 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_029, TestSize.Level0)
1035 {
1036 UserAuthService service;
1037 int32_t apiVersion = 10;
1038 std::vector<uint8_t> challenge = {1};
1039 std::vector<int32_t> authTypes = {PIN};
1040 IpcAuthParamInner authParam;
1041 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1042 authParam.isUserIdSpecified = true;
1043 IpcWidgetParamInner widgetParam;
1044 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
1045 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1046 EXPECT_NE(testCallback, nullptr);
1047 IpcCommon::AddPermission(IS_SYSTEM_APP);
1048 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1049 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1050 EXPECT_NE(mockHdi, nullptr);
1051 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1052 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1053 ON_CALL(*mockHdi, GetValidSolution)
1054 .WillByDefault(
1055 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761502(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 1056 std::vector<int32_t>& validTypes) {
1057 validTypes.clear();
1058 validTypes.push_back(AuthType::PIN);
1059 return HDF_SUCCESS;
1060 }
1061 );
1062 sptr<IModalCallback> testModalCallback(nullptr);
1063 uint64_t contextId = 0;
1064 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1065 EXPECT_EQ(ret, GENERAL_ERROR);
1066 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1067 IpcCommon::DeleteAllPermission();
1068 }
1069
1070 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_030, TestSize.Level0)
1071 {
1072 UserAuthService service;
1073 int32_t apiVersion = 10;
1074 std::vector<uint8_t> challenge = {1};
1075 std::vector<int32_t> authTypes = {PIN};
1076 IpcAuthParamInner authParam;
1077 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1078 authParam.isUserIdSpecified = true;
1079 IpcWidgetParamInner widgetParam;
1080 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
1081 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1082 EXPECT_NE(testCallback, nullptr);
1083 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1084 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1085 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1086 EXPECT_NE(mockHdi, nullptr);
1087 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1088 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1089 ON_CALL(*mockHdi, GetValidSolution)
1090 .WillByDefault(
1091 [](int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel,
__anona135bf761602(int32_t userId, const std::vector<int32_t>& authTypes, uint32_t authTrustLevel, std::vector<int32_t>& validTypes) 1092 std::vector<int32_t>& validTypes) {
1093 validTypes.clear();
1094 validTypes.push_back(AuthType::PIN);
1095 return HDF_SUCCESS;
1096 }
1097 );
1098 sptr<IModalCallback> testModalCallback(nullptr);
1099 uint64_t contextId = 0;
1100 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1101 EXPECT_EQ(ret, INVALID_PARAMETERS);
1102 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1103 IpcCommon::DeleteAllPermission();
1104 }
1105
1106 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_031, TestSize.Level0)
1107 {
1108 UserAuthService service;
1109 int32_t apiVersion = 10;
1110 std::vector<uint8_t> challenge = {1};
1111 std::vector<int32_t> authTypes = {FACE, FINGERPRINT};
1112 IpcAuthParamInner authParam;
1113 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1114 IpcWidgetParamInner widgetParam;
1115 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
1116 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1117 EXPECT_NE(testCallback, nullptr);
1118 IpcCommon::AddPermission(IS_SYSTEM_APP);
1119 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1120 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1121 EXPECT_NE(mockHdi, nullptr);
1122 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1123 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1124 sptr<IModalCallback> testModalCallback(nullptr);
1125 uint64_t contextId = 0;
1126 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1127 EXPECT_EQ(ret, INVALID_PARAMETERS);
1128 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1129 IpcCommon::DeleteAllPermission();
1130 }
1131
1132 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_032, TestSize.Level0)
1133 {
1134 UserAuthService service;
1135 int32_t apiVersion = 10;
1136 std::vector<uint8_t> challenge = {1};
1137 std::vector<int32_t> authTypes = {FINGERPRINT, FACE};
1138 IpcAuthParamInner authParam;
1139 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1140 IpcWidgetParamInner widgetParam;
1141 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "", WindowModeType::FULLSCREEN);
1142 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1143 EXPECT_NE(testCallback, nullptr);
1144 IpcCommon::AddPermission(IS_SYSTEM_APP);
1145 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1146 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1147 EXPECT_NE(mockHdi, nullptr);
1148 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1149 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1150 sptr<IModalCallback> testModalCallback(nullptr);
1151 uint64_t contextId = 0;
1152 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1153 EXPECT_EQ(ret, INVALID_PARAMETERS);
1154 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1155 IpcCommon::DeleteAllPermission();
1156 }
1157
1158 HWTEST_F(UserAuthServiceTest, UserAuthServiceAuthWidget_033, TestSize.Level0)
1159 {
1160 UserAuthService service;
1161 int32_t apiVersion = 10;
1162 std::vector<uint8_t> challenge = {1};
1163 std::vector<int32_t> authTypes = {FINGERPRINT, FACE, PRIVATE_PIN};
1164 IpcAuthParamInner authParam;
1165 InitIpcAuthParamInner(authParam, challenge, authTypes, ATL2);
1166 IpcWidgetParamInner widgetParam;
1167 InitIpcWidgetParamInner(widgetParam, "使用密码验证", "test", WindowModeType::DIALOG_BOX);
1168 sptr<IIamCallback> testCallback = new MockUserAuthCallback();
1169 EXPECT_NE(testCallback, nullptr);
1170 IpcCommon::AddPermission(IS_SYSTEM_APP);
1171 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1172 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1173 EXPECT_NE(mockHdi, nullptr);
1174 EXPECT_CALL(*mockHdi, GetAvailableStatus(_, _, _, _)).Times(0);
1175 EXPECT_CALL(*mockHdi, BeginAuthentication(_, _, _)).Times(0);
1176 sptr<IModalCallback> testModalCallback(nullptr);
1177 uint64_t contextId = 0;
1178 int32_t ret = service.AuthWidget(apiVersion, authParam, widgetParam, testCallback, testModalCallback, contextId);
1179 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
1180 EXPECT_EQ(contextId, BAD_CONTEXT_ID);
1181 IpcCommon::DeleteAllPermission();
1182 }
1183
1184 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckAuthPermissionAndParam_001, TestSize.Level0)
1185 {
1186 UserAuthService service;
1187 std::vector<uint8_t> challenge = {1};
1188 const AuthParamInner authParam = {
1189 .challenge = challenge,
1190 .authTypes = {PIN, FACE, PRIVATE_PIN},
1191 .authTrustLevel = ATL2,
1192 .isUserIdSpecified = true,
1193 };
1194 const WidgetParamInner widgetParam = {
1195 .title = "使用密码验证",
1196 .navigationButtonText = "navigationButtonText",
1197 .windowMode = WindowModeType::NONE_INTERRUPTION_DIALOG_BOX,
1198 };
1199 int32_t ret = service.CheckAuthPermissionAndParam(authParam, widgetParam, true);
1200 EXPECT_EQ(ret, CHECK_SYSTEM_APP_FAILED);
1201 }
1202
1203 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckAuthPermissionAndParam_002, TestSize.Level0)
1204 {
1205 UserAuthService service;
1206 std::vector<uint8_t> challenge = {1};
1207 const AuthParamInner authParam = {
1208 .challenge = challenge,
1209 .authTypes = {PIN, FACE, PRIVATE_PIN},
1210 .authTrustLevel = ATL2,
1211 .isUserIdSpecified = true,
1212 };
1213 const WidgetParamInner widgetParam = {
1214 .title = "使用密码验证",
1215 .navigationButtonText = "navigationButtonText",
1216 .windowMode = WindowModeType::UNKNOWN_WINDOW_MODE,
1217 };
1218 int32_t ret = service.CheckAuthPermissionAndParam(authParam, widgetParam, true);
1219 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
1220 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1221 ret = service.CheckAuthPermissionAndParam(authParam, widgetParam, true);
1222 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
1223 IpcCommon::DeleteAllPermission();
1224 }
1225
1226 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckAuthPermissionAndParam_003, TestSize.Level0)
1227 {
1228 UserAuthService service;
1229 std::vector<uint8_t> challenge = {1};
1230 const AuthParamInner authParam = {
1231 .challenge = challenge,
1232 .authTypes = {PIN, FACE, PRIVATE_PIN},
1233 .authTrustLevel = ATL2,
1234 .isUserIdSpecified = true,
1235 };
1236 const WidgetParamInner widgetParam = {
1237 .title = "使用密码验证",
1238 .navigationButtonText = "navigationButtonText",
1239 .windowMode = WindowModeType::UNKNOWN_WINDOW_MODE,
1240 };
1241 IpcCommon::AddPermission(IS_SYSTEM_APP);
1242 int32_t ret = service.CheckAuthPermissionAndParam(authParam, widgetParam, true);
1243 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
1244 IpcCommon::DeleteAllPermission();
1245 }
1246
1247 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckAuthPermissionAndParam_004, TestSize.Level0)
1248 {
1249 UserAuthService service;
1250 std::vector<uint8_t> challenge = {1};
1251 const AuthParamInner authParam = {
1252 .userId = 200,
1253 .challenge = challenge,
1254 .authTypes = {PIN, FACE, PRIVATE_PIN},
1255 .authTrustLevel = ATL2,
1256 .isUserIdSpecified = true,
1257 };
1258 const WidgetParamInner widgetParam = {
1259 .navigationButtonText = "navigationButtonText",
1260 .windowMode = WindowModeType::UNKNOWN_WINDOW_MODE,
1261 };
1262 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1263 IpcCommon::AddPermission(IS_SYSTEM_APP);
1264 IpcCommon::AddPermission(USER_AUTH_FROM_BACKGROUND);
1265 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1266 int32_t ret = service.CheckAuthPermissionAndParam(authParam, widgetParam, true);
1267 EXPECT_EQ(ret, INVALID_PARAMETERS);
1268 IpcCommon::DeleteAllPermission();
1269 }
1270
1271 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckValidSolution_002, TestSize.Level0)
1272 {
1273 UserAuthService service;
1274 std::vector<uint8_t> challenge = {1};
1275 const WidgetParamInner widgetParam = {
1276 .title = "使用密码验证",
1277 .navigationButtonText = "navigationButtonText",
1278 .windowMode = WindowModeType::UNKNOWN_WINDOW_MODE,
1279 };
1280 IpcCommon::AddPermission(ACCESS_BIOMETRIC_PERMISSION);
1281 IpcCommon::AddPermission(IS_SYSTEM_APP);
1282 IpcCommon::AddPermission(USER_AUTH_FROM_BACKGROUND);
1283 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1284 int32_t userId = 100;
1285 std::vector<AuthType> authTypeList;
1286 authTypeList.push_back(FACE);
1287 authTypeList.push_back(ALL);
1288 authTypeList.push_back(PIN);
1289 authTypeList.push_back(FINGERPRINT);
1290 AuthTrustLevel atl = ATL3;
1291 const AuthParamInner authParam = {
1292 .userId = userId,
1293 .challenge = challenge,
1294 .authTypes = authTypeList,
1295 .authTrustLevel = atl,
1296 .isUserIdSpecified = true,
1297 };
1298 std::vector<AuthType> validTypeList;
1299 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1300 EXPECT_NE(mockHdi, nullptr);
1301 EXPECT_CALL(*mockHdi, GetValidSolution(_, _, _, _)).WillOnce(Return(HDF_SUCCESS));
1302 int32_t ret = service.CheckValidSolution(userId, authParam, widgetParam, validTypeList);
1303 EXPECT_EQ(ret, TYPE_NOT_SUPPORT);
1304 MockIUserAuthInterface::Holder::GetInstance().Reset();
1305 IpcCommon::DeleteAllPermission();
1306 }
1307
1308 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckPrivatePinEnroll001, TestSize.Level0)
1309 {
1310 UserAuthService service;
1311 std::vector<AuthType> authTypeList;
1312 authTypeList.push_back(AuthType::FINGERPRINT);
1313 authTypeList.push_back(AuthType::FACE);
1314 authTypeList.push_back(AuthType::PRIVATE_PIN);
1315 std::vector<AuthType> validAuthTypeList;
1316 validAuthTypeList.push_back(AuthType::FINGERPRINT);
1317 validAuthTypeList.push_back(AuthType::FACE);
1318 EXPECT_EQ(service.CheckPrivatePinEnroll(authTypeList, validAuthTypeList), false);
1319 }
1320
1321 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckPrivatePinEnroll002, TestSize.Level0)
1322 {
1323 UserAuthService service;
1324 std::vector<AuthType> authTypeList;
1325 authTypeList.push_back(AuthType::FINGERPRINT);
1326 authTypeList.push_back(AuthType::FACE);
1327 authTypeList.push_back(AuthType::PRIVATE_PIN);
1328 std::vector<AuthType> validAuthTypeList;
1329 validAuthTypeList.push_back(AuthType::PRIVATE_PIN);
1330 validAuthTypeList.push_back(AuthType::FACE);
1331 EXPECT_EQ(service.CheckPrivatePinEnroll(authTypeList, validAuthTypeList), true);
1332 }
1333
1334 HWTEST_F(UserAuthServiceTest, UserAuthServiceCheckPrivatePinEnroll003, TestSize.Level0)
1335 {
1336 UserAuthService service;
1337 std::vector<AuthType> authTypeList;
1338 authTypeList.push_back(AuthType::FINGERPRINT);
1339 authTypeList.push_back(AuthType::FACE);
1340 authTypeList.push_back(AuthType::PRIVATE_PIN);
1341 std::vector<AuthType> validAuthTypeList;
1342 validAuthTypeList.push_back(AuthType::FINGERPRINT);
1343 validAuthTypeList.push_back(AuthType::PRIVATE_PIN);
1344 EXPECT_EQ(service.CheckPrivatePinEnroll(authTypeList, validAuthTypeList), true);
1345 }
1346
1347 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_001, TestSize.Level0)
1348 {
1349 UserAuthService service;
1350 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1351 int32_t ret = service.Notice(static_cast<int32_t>(NoticeType::WIDGET_NOTICE), "PIN");
1352 EXPECT_NE(ret, ResultCode::SUCCESS);
1353 IpcCommon::DeleteAllPermission();
1354 }
1355
1356 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_002, TestSize.Level0)
1357 {
1358 UserAuthService service;
1359 IpcCommon::AddPermission(IS_SYSTEM_APP);
1360 int32_t ret = service.Notice(static_cast<int32_t>(NoticeType::WIDGET_NOTICE), "PIN");
1361 EXPECT_EQ(ret, ResultCode::CHECK_PERMISSION_FAILED);
1362 IpcCommon::DeleteAllPermission();
1363 }
1364
1365 HWTEST_F(UserAuthServiceTest, UserAuthServiceNotice_003, TestSize.Level0)
1366 {
1367 UserAuthService service;
1368 IpcCommon::AddPermission(IS_SYSTEM_APP);
1369 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1370 int32_t ret = service.Notice(static_cast<int32_t>(NoticeType::WIDGET_NOTICE), "PIN");
1371 EXPECT_EQ(ret, ResultCode::INVALID_PARAMETERS);
1372 IpcCommon::DeleteAllPermission();
1373 }
1374
1375 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_001, TestSize.Level0)
1376 {
1377 UserAuthService service;
1378 sptr<IWidgetCallback> testCallback = nullptr;
1379 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_SYSTEM_APP_FAILED);
1380 }
1381
1382 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_002, TestSize.Level0)
1383 {
1384 UserAuthService service;
1385 sptr<IWidgetCallback> testCallback = nullptr;
1386 IpcCommon::AddPermission(IS_SYSTEM_APP);
1387 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1388 IpcCommon::DeleteAllPermission();
1389 }
1390
1391 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_003, TestSize.Level0)
1392 {
1393 UserAuthService service;
1394 sptr<IWidgetCallback> testCallback = nullptr;
1395 IpcCommon::AddPermission(IS_SYSTEM_APP);
1396 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1397 EXPECT_EQ(service.RegisterWidgetCallback(2, testCallback), ResultCode::INVALID_PARAMETERS);
1398 IpcCommon::DeleteAllPermission();
1399 }
1400
1401 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_004, TestSize.Level0)
1402 {
1403 UserAuthService service;
1404 sptr<IWidgetCallback> testCallback = nullptr;
1405 IpcCommon::AddPermission(IS_SYSTEM_APP);
1406 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1407 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::INVALID_PARAMETERS);
1408 IpcCommon::DeleteAllPermission();
1409 }
1410
1411 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_005, TestSize.Level0)
1412 {
1413 UserAuthService service;
1414 sptr<IWidgetCallback> testCallback = new MockIWidgetCallback();
1415 IpcCommon::AddPermission(IS_SYSTEM_APP);
1416 IpcCommon::AddPermission(SUPPORT_USER_AUTH);
1417 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::SUCCESS);
1418 IpcCommon::DeleteAllPermission();
1419 }
1420
1421 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegisterWidgetCallback_006, TestSize.Level0)
1422 {
1423 UserAuthService service;
1424 sptr<IWidgetCallback> testCallback = nullptr;
1425 IpcCommon::AddPermission(IS_SYSTEM_APP);
1426 EXPECT_EQ(service.RegisterWidgetCallback(1, testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1427 IpcCommon::DeleteAllPermission();
1428 }
1429
1430 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_001, TestSize.Level0)
1431 {
1432 UserAuthService service;
1433 sptr<IEventListenerCallback> testCallback = nullptr;
1434 IpcCommon::AddPermission(IS_SYSTEM_APP);
1435 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(testCallback), ResultCode::INVALID_PARAMETERS);
1436 IpcCommon::DeleteAllPermission();
1437 }
1438
1439 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_003, TestSize.Level0)
1440 {
1441 UserAuthService service;
1442 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1443 IpcCommon::AddPermission(IS_SYSTEM_APP);
1444 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(testCallback),
1445 ResultCode::CHECK_PERMISSION_FAILED);
1446 IpcCommon::DeleteAllPermission();
1447 }
1448
1449 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_004, TestSize.Level0)
1450 {
1451 UserAuthService service;
1452 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1453 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1454 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(testCallback),
1455 ResultCode::GENERAL_ERROR);
1456 IpcCommon::DeleteAllPermission();
1457 }
1458
1459 HWTEST_F(UserAuthServiceTest, UserAuthServiceRegistEventListerner_005, TestSize.Level0)
1460 {
1461 UserAuthService service;
1462 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1463 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(testCallback),
1464 ResultCode::CHECK_PERMISSION_FAILED);
1465 IpcCommon::DeleteAllPermission();
1466 }
1467
1468 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_001, TestSize.Level0)
1469 {
1470 UserAuthService service;
1471 sptr<IEventListenerCallback> testCallback = nullptr;
1472 IpcCommon::AddPermission(IS_SYSTEM_APP);
1473 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::INVALID_PARAMETERS);
1474 IpcCommon::DeleteAllPermission();
1475 }
1476
1477 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_002, TestSize.Level0)
1478 {
1479 UserAuthService service;
1480 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1481 IpcCommon::AddPermission(IS_SYSTEM_APP);
1482 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::CHECK_PERMISSION_FAILED);
1483 IpcCommon::DeleteAllPermission();
1484 }
1485
1486 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_003, TestSize.Level0)
1487 {
1488 UserAuthService service;
1489 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1490 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1491 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::GENERAL_ERROR);
1492 IpcCommon::DeleteAllPermission();
1493 }
1494
1495 HWTEST_F(UserAuthServiceTest, UserAuthServiceUnRegistEventListerner_004, TestSize.Level0)
1496 {
1497 UserAuthService service;
1498 sptr<IEventListenerCallback> testCallback = new MockEventListener();
1499 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1500 EXPECT_EQ(service.RegistUserAuthSuccessEventListener(testCallback), ResultCode::GENERAL_ERROR);
1501 EXPECT_EQ(service.UnRegistUserAuthSuccessEventListener(testCallback), ResultCode::GENERAL_ERROR);
1502 IpcCommon::DeleteAllPermission();
1503 }
1504
1505 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetGlobalConfigParam001, TestSize.Level0)
1506 {
1507 UserAuthService service;
1508 IpcGlobalConfigParam param = {};
1509 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::CHECK_PERMISSION_FAILED);
1510
1511 IpcCommon::AddPermission(ENTERPRISE_DEVICE_MGR);
1512 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1513 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1514
1515 param.type = PIN_EXPIRED_PERIOD;
1516 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1517 param.authTypes.push_back(PIN);
1518 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::SUCCESS);
1519
1520 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1521 EXPECT_NE(mockHdi, nullptr);
1522 EXPECT_CALL(*mockHdi, SetGlobalConfigParam(_)).Times(1);
1523 ON_CALL(*mockHdi, SetGlobalConfigParam)
1524 .WillByDefault(
__anona135bf761702(const HdiGlobalConfigParam ¶m) 1525 [](const HdiGlobalConfigParam ¶m) {
1526 return HDF_SUCCESS;
1527 }
1528 );
1529 EXPECT_EQ(service.SetGlobalConfigParam(param), HDF_SUCCESS);
1530 IpcCommon::DeleteAllPermission();
1531 }
1532
1533 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetGlobalConfigParam002, TestSize.Level0)
1534 {
1535 UserAuthService service;
1536 IpcGlobalConfigParam param = {};
1537 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::CHECK_PERMISSION_FAILED);
1538
1539 IpcCommon::AddPermission(ENTERPRISE_DEVICE_MGR);
1540 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1541 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1542
1543 param.type = ENABLE_STATUS;
1544 param.value.enableStatus = true;
1545 param.userIds.push_back(1);
1546 param.authTypes.push_back(PIN);
1547 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::SUCCESS);
1548
1549 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1550 EXPECT_NE(mockHdi, nullptr);
1551 EXPECT_CALL(*mockHdi, SetGlobalConfigParam(_)).Times(1);
1552 ON_CALL(*mockHdi, SetGlobalConfigParam)
1553 .WillByDefault(
__anona135bf761802(const HdiGlobalConfigParam ¶m) 1554 [](const HdiGlobalConfigParam ¶m) {
1555 return HDF_FAILURE;
1556 }
1557 );
1558 EXPECT_EQ(service.SetGlobalConfigParam(param), HDF_FAILURE);
1559 IpcCommon::DeleteAllPermission();
1560 }
1561
1562 HWTEST_F(UserAuthServiceTest, UserAuthServiceSetGlobalConfigParam003, TestSize.Level0)
1563 {
1564 UserAuthService service;
1565 IpcGlobalConfigParam param = {};
1566 IpcCommon::AddPermission(ENTERPRISE_DEVICE_MGR);
1567 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1568 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1569
1570 param.type = PIN_EXPIRED_PERIOD;
1571 param.value.enableStatus = true;
1572 param.userIds.push_back(1);
1573 param.authTypes.push_back(ALL);
1574 param.authTypes.push_back(PIN);
1575 param.authTypes.push_back(FACE);
1576 param.authTypes.push_back(FINGERPRINT);
1577 param.authTypes.push_back(RECOVERY_KEY);
1578 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1579 param.authTypes.clear();
1580 param.authTypes.push_back(FACE);
1581 EXPECT_EQ(service.SetGlobalConfigParam(param), ResultCode::INVALID_PARAMETERS);
1582 IpcCommon::DeleteAllPermission();
1583 }
1584
1585 HWTEST_F(UserAuthServiceTest, UserAuthServiceVerifyAuthToken001, TestSize.Level0)
1586 {
1587 UserAuthService service;
1588 std::vector<uint8_t> testTokenIn = {};
1589 testTokenIn.resize(1);
1590 uint64_t allowableDuration = 0;
1591
1592 sptr<MockVerifyTokenCallback> testCallback(nullptr);
1593
1594 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1595 EXPECT_NE(mockHdi, nullptr);
1596 EXPECT_CALL(*mockHdi, VerifyAuthToken(_, _, _, _))
1597 .WillOnce([](const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration,
__anona135bf761902(const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration, HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) 1598 HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) {
1599 return HDF_SUCCESS;
1600 });
1601
1602 testCallback = sptr<MockVerifyTokenCallback>(new (std::nothrow) MockVerifyTokenCallback());
1603 EXPECT_NE(testCallback, nullptr);
1604 EXPECT_CALL(*testCallback, OnVerifyTokenResult(_, _)).Times(1);
1605 IpcCommon::AddPermission(USE_USER_ACCESS_MANAGER);
1606 IpcCommon::AddPermission(IS_SYSTEM_APP);
1607 sptr<IVerifyTokenCallback> callbackInterface = testCallback;
1608 service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface);
1609 IpcCommon::DeleteAllPermission();
1610 }
1611
1612 HWTEST_F(UserAuthServiceTest, UserAuthServiceVerifyAuthToken002, TestSize.Level0)
1613 {
1614 UserAuthService service;
1615 std::vector<uint8_t> testTokenIn = {};
1616 uint64_t allowableDuration = 0;
1617 sptr<MockVerifyTokenCallback> testCallback(nullptr);
1618 testCallback = sptr<MockVerifyTokenCallback>(new (std::nothrow) MockVerifyTokenCallback());
1619 EXPECT_NE(testCallback, nullptr);
1620 EXPECT_CALL(*testCallback, OnVerifyTokenResult(_, _)).Times(2);
1621 sptr<IVerifyTokenCallback> callbackInterface = testCallback;
1622 EXPECT_EQ(service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface), INVALID_PARAMETERS);
1623
1624 testTokenIn.resize(1);
1625 allowableDuration = 25 * 60 * 60 * 1000;
1626 service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface);
1627 }
1628
1629 HWTEST_F(UserAuthServiceTest, UserAuthServiceVerifyAuthToken003, TestSize.Level0)
1630 {
1631 UserAuthService service;
1632 std::vector<uint8_t> testTokenIn = {};
1633 testTokenIn.resize(1);
1634 uint64_t allowableDuration = 0;
1635 sptr<MockVerifyTokenCallback> testCallback(nullptr);
1636 testCallback = sptr<MockVerifyTokenCallback>(new (std::nothrow) MockVerifyTokenCallback());
1637 EXPECT_NE(testCallback, nullptr);
1638 EXPECT_CALL(*testCallback, OnVerifyTokenResult(_, _)).Times(2);
1639 sptr<IVerifyTokenCallback> callbackInterface = testCallback;
1640 service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface);
1641
1642 IpcCommon::AddPermission(USE_USER_ACCESS_MANAGER);
1643 EXPECT_EQ(service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface), CHECK_SYSTEM_APP_FAILED);
1644 IpcCommon::DeleteAllPermission();
1645 }
1646
1647 HWTEST_F(UserAuthServiceTest, UserAuthServiceVerifyAuthToken004, TestSize.Level0)
1648 {
1649 UserAuthService service;
1650 std::vector<uint8_t> testTokenIn = {};
1651 testTokenIn.resize(1);
1652 uint64_t allowableDuration = 0;
1653
1654 sptr<MockVerifyTokenCallback> testCallback(nullptr);
1655
1656 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1657 EXPECT_NE(mockHdi, nullptr);
1658 EXPECT_CALL(*mockHdi, VerifyAuthToken(_, _, _, _))
1659 .WillOnce([](const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration,
__anona135bf761a02(const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration, HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) 1660 HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) {
1661 return HDF_FAILURE;
1662 });
1663
1664 testCallback = sptr<MockVerifyTokenCallback>(new (std::nothrow) MockVerifyTokenCallback());
1665 EXPECT_NE(testCallback, nullptr);
1666 EXPECT_CALL(*testCallback, OnVerifyTokenResult(_, _)).Times(1);
1667 IpcCommon::AddPermission(USE_USER_ACCESS_MANAGER);
1668 IpcCommon::AddPermission(IS_SYSTEM_APP);
1669 sptr<IVerifyTokenCallback> callbackInterface = testCallback;
1670 EXPECT_EQ(service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface), HDF_FAILURE);
1671 IpcCommon::DeleteAllPermission();
1672 }
1673
1674 HWTEST_F(UserAuthServiceTest, UserAuthServiceVerifyAuthToken005, TestSize.Level0)
1675 {
1676 UserAuthService service;
1677 std::vector<uint8_t> testTokenIn = {};
1678 testTokenIn.resize(1);
1679 uint64_t allowableDuration = 0;
1680
1681 sptr<MockVerifyTokenCallback> testCallback(nullptr);
1682
1683 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1684 EXPECT_NE(mockHdi, nullptr);
1685 EXPECT_CALL(*mockHdi, VerifyAuthToken(_, _, _, _))
1686 .WillOnce([](const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration,
__anona135bf761b02(const std::vector<uint8_t>& tokenIn, uint64_t allowableDuration, HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) 1687 HdiUserAuthTokenPlain &tokenPlainOut, std::vector<uint8_t>& rootSecret) {
1688 rootSecret.push_back(1);
1689 return HDF_SUCCESS;
1690 });
1691
1692 testCallback = sptr<MockVerifyTokenCallback>(new (std::nothrow) MockVerifyTokenCallback());
1693 EXPECT_NE(testCallback, nullptr);
1694 EXPECT_CALL(*testCallback, OnVerifyTokenResult(_, _)).Times(1);
1695 IpcCommon::AddPermission(USE_USER_ACCESS_MANAGER);
1696 IpcCommon::AddPermission(IS_SYSTEM_APP);
1697 sptr<IVerifyTokenCallback> callbackInterface = testCallback;
1698 EXPECT_EQ(service.VerifyAuthToken(testTokenIn, allowableDuration, callbackInterface), SUCCESS);
1699 IpcCommon::DeleteAllPermission();
1700 }
1701
1702 HWTEST_F(UserAuthServiceTest, QueryReusableAuthResult001, TestSize.Level0)
1703 {
1704 UserAuthService service;
1705 std::vector<uint8_t> tempChallenge = {};
1706 tempChallenge.resize(32);
1707 IpcAuthParamInner ipcAuthParamInner = {};
1708 ipcAuthParamInner.userId = 1;
1709 ipcAuthParamInner.isUserIdSpecified = true;
1710 ipcAuthParamInner.challenge = tempChallenge;
1711 ipcAuthParamInner.authTrustLevel = ATL3;
1712 ipcAuthParamInner.authTypes.push_back(PIN);
1713 ipcAuthParamInner.reuseUnlockResult.isReuse = true;
1714 ipcAuthParamInner.reuseUnlockResult.reuseMode = AUTH_TYPE_RELEVANT;
1715 ipcAuthParamInner.reuseUnlockResult.reuseDuration = 5 * 60 * 1000;
1716
1717 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1718 EXPECT_NE(mockHdi, nullptr);
1719 EXPECT_CALL(*mockHdi, CheckReuseUnlockResult(_, _))
__anona135bf761c02(const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) 1720 .WillOnce([](const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) {
1721 static const uint32_t USER_AUTH_TOKEN_LEN = 148;
1722 reuseInfo.token.resize(USER_AUTH_TOKEN_LEN);
1723 return HDF_SUCCESS;
1724 });
1725
1726 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1727 IpcCommon::AddPermission(IS_SYSTEM_APP);
1728 std::vector<uint8_t> token;
1729 EXPECT_EQ(service.QueryReusableAuthResult(ipcAuthParamInner, token), SUCCESS);
1730 IpcCommon::DeleteAllPermission();
1731 }
1732
1733 HWTEST_F(UserAuthServiceTest, QueryReusableAuthResult002, TestSize.Level0)
1734 {
1735 UserAuthService service;
1736 std::vector<uint8_t> tempChallenge = {};
1737 tempChallenge.resize(32);
1738 IpcAuthParamInner ipcAuthParamInner = {};
1739 ipcAuthParamInner.userId = 1;
1740 ipcAuthParamInner.isUserIdSpecified = true;
1741 ipcAuthParamInner.challenge = tempChallenge;
1742 ipcAuthParamInner.authTrustLevel = ATL3;
1743 ipcAuthParamInner.authTypes.push_back(PIN);
1744 ipcAuthParamInner.reuseUnlockResult.isReuse = true;
1745 ipcAuthParamInner.reuseUnlockResult.reuseMode = AUTH_TYPE_RELEVANT;
1746 ipcAuthParamInner.reuseUnlockResult.reuseDuration = 5 * 60 * 1000;
1747
1748 IpcCommon::AddPermission(IS_SYSTEM_APP);
1749 std::vector<uint8_t> token;
1750 EXPECT_EQ(service.QueryReusableAuthResult(ipcAuthParamInner, token), CHECK_PERMISSION_FAILED);
1751 IpcCommon::DeleteAllPermission();
1752 }
1753
1754 HWTEST_F(UserAuthServiceTest, QueryReusableAuthResult003, TestSize.Level0)
1755 {
1756 UserAuthService service;
1757 std::vector<uint8_t> tempChallenge = {};
1758 tempChallenge.resize(32);
1759 IpcAuthParamInner ipcAuthParamInner = {};
1760 ipcAuthParamInner.userId = 1;
1761 ipcAuthParamInner.isUserIdSpecified = true;
1762 ipcAuthParamInner.challenge = tempChallenge;
1763 ipcAuthParamInner.authTrustLevel = ATL3;
1764 ipcAuthParamInner.authTypes.push_back(PIN);
1765 ipcAuthParamInner.reuseUnlockResult.isReuse = true;
1766 ipcAuthParamInner.reuseUnlockResult.reuseMode = AUTH_TYPE_RELEVANT;
1767 ipcAuthParamInner.reuseUnlockResult.reuseDuration = 5 * 60 * 1000;
1768
1769 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1770 std::vector<uint8_t> token;
1771 EXPECT_EQ(service.QueryReusableAuthResult(ipcAuthParamInner, token), CHECK_SYSTEM_APP_FAILED);
1772 IpcCommon::DeleteAllPermission();
1773 }
1774
1775 HWTEST_F(UserAuthServiceTest, QueryReusableAuthResult004, TestSize.Level0)
1776 {
1777 UserAuthService service;
1778 std::vector<uint8_t> tempChallenge = {};
1779 tempChallenge.resize(32);
1780 IpcAuthParamInner ipcAuthParamInner = {};
1781 ipcAuthParamInner.userId = 1;
1782 ipcAuthParamInner.isUserIdSpecified = true;
1783 ipcAuthParamInner.challenge = tempChallenge;
1784 ipcAuthParamInner.authTrustLevel = ATL3;
1785 ipcAuthParamInner.authTypes.push_back(PIN);
1786 ipcAuthParamInner.reuseUnlockResult.isReuse = true;
1787 ipcAuthParamInner.reuseUnlockResult.reuseMode = AUTH_TYPE_RELEVANT;
1788 ipcAuthParamInner.reuseUnlockResult.reuseDuration = 5 * 60 * 1000;
1789
1790 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1791 EXPECT_NE(mockHdi, nullptr);
1792 EXPECT_CALL(*mockHdi, CheckReuseUnlockResult(_, _))
__anona135bf761d02(const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) 1793 .WillOnce([](const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) {
1794 return HDF_FAILURE;
1795 });
1796
1797 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1798 IpcCommon::AddPermission(IS_SYSTEM_APP);
1799 std::vector<uint8_t> token;
1800 EXPECT_EQ(service.QueryReusableAuthResult(ipcAuthParamInner, token), HDF_FAILURE);
1801 IpcCommon::DeleteAllPermission();
1802 }
1803
1804 HWTEST_F(UserAuthServiceTest, QueryReusableAuthResult005, TestSize.Level0)
1805 {
1806 UserAuthService service;
1807 std::vector<uint8_t> tempChallenge = {};
1808 tempChallenge.resize(32);
1809 IpcAuthParamInner ipcAuthParamInner = {};
1810 ipcAuthParamInner.userId = 1;
1811 ipcAuthParamInner.isUserIdSpecified = true;
1812 ipcAuthParamInner.challenge = tempChallenge;
1813 ipcAuthParamInner.authTrustLevel = ATL3;
1814 ipcAuthParamInner.authTypes.push_back(PIN);
1815 ipcAuthParamInner.reuseUnlockResult.isReuse = true;
1816 ipcAuthParamInner.reuseUnlockResult.reuseMode = AUTH_TYPE_RELEVANT;
1817 ipcAuthParamInner.reuseUnlockResult.reuseDuration = 5 * 60 * 1000;
1818
1819 auto mockHdi = MockIUserAuthInterface::Holder::GetInstance().Get();
1820 EXPECT_NE(mockHdi, nullptr);
1821 EXPECT_CALL(*mockHdi, CheckReuseUnlockResult(_, _))
__anona135bf761e02(const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) 1822 .WillOnce([](const HdiReuseUnlockParam &info, HdiReuseUnlockInfo &reuseInfo) {
1823 return HDF_SUCCESS;
1824 });
1825
1826 IpcCommon::AddPermission(ACCESS_USER_AUTH_INTERNAL_PERMISSION);
1827 IpcCommon::AddPermission(IS_SYSTEM_APP);
1828 std::vector<uint8_t> token;
1829 EXPECT_EQ(service.QueryReusableAuthResult(ipcAuthParamInner, token), SUCCESS);
1830 IpcCommon::DeleteAllPermission();
1831 }
1832 } // namespace UserAuth
1833 } // namespace UserIam
1834 } // namespace OHOS