1 /*
2  * Copyright (c) 2024-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 "gtest/gtest.h"
17 
18 #include "hdf_base.h"
19 #include "iam_logger.h"
20 #include "iam_ptr.h"
21 
22 #include "pin_auth_verifier_hdi.h"
23 #include "iam_common_defines.h"
24 #include "mock_iexecute_callback.h"
25 #include "mock_iverifier_executor.h"
26 
27 #define LOG_TAG "PIN_AUTH_SA"
28 
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace OHOS::UserIam::Common;
32 
33 namespace OHOS {
34 namespace UserIam {
35 namespace PinAuth {
36 using IamResultCode = OHOS::UserIam::UserAuth::ResultCode;
37 using IamExecutorRole = OHOS::UserIam::UserAuth::ExecutorRole;
38 using IamExecutorInfo = OHOS::UserIam::UserAuth::ExecutorInfo;
39 using IamAuthType = OHOS::UserIam::UserAuth::AuthType;
40 using IamExecutorSecureLevel = OHOS::UserIam::UserAuth::ExecutorSecureLevel;
41 using IamPropertyMode = OHOS::UserIam::UserAuth::PropertyMode;
42 namespace {
43 static const std::map<HDF_STATUS, IamResultCode> RESULT_CODE_MAP = {
44     {HDF_SUCCESS, UserAuth::ResultCode::SUCCESS},
45     {HDF_FAILURE, UserAuth::ResultCode::GENERAL_ERROR},
46     {HDF_ERR_TIMEOUT, UserAuth::ResultCode::TIMEOUT},
47     {HDF_ERR_QUEUE_FULL, UserAuth::ResultCode::BUSY},
48     {HDF_ERR_DEVICE_BUSY, UserAuth::ResultCode::BUSY},
49     {HDF_ERR_INVALID_PARAM, UserAuth::ResultCode::INVALID_PARAMETERS},
50 };
51 }
52 
53 class PinAuthVerifierHdiUnitTest : public testing::Test {
54 public:
55     static void SetUpTestCase();
56     static void TearDownTestCase();
57     void SetUp();
58     void TearDown();
59 };
60 
SetUpTestCase()61 void PinAuthVerifierHdiUnitTest::SetUpTestCase()
62 {
63 }
64 
TearDownTestCase()65 void PinAuthVerifierHdiUnitTest::TearDownTestCase()
66 {
67 }
68 
SetUp()69 void PinAuthVerifierHdiUnitTest::SetUp()
70 {
71 }
72 
TearDown()73 void PinAuthVerifierHdiUnitTest::TearDown()
74 {
75 }
76 
77 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_001, TestSize.Level0)
78 {
79     auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
80     ASSERT_TRUE(executorProxy != nullptr);
__anon22e5e7820202(ExecutorInfo &info) 81     EXPECT_CALL(*executorProxy, GetExecutorInfo(_)).Times(Exactly(1)).WillOnce([](ExecutorInfo &info) {
82         info = {
83             .executorRole = ExecutorRole::VERIFIER,
84             .authType = AuthType::PIN,
85             .esl = ExecutorSecureLevel::ESL0,
86         };
87         return HDF_SUCCESS;
88     });
89     PinAuthVerifierHdi verifyHdi(executorProxy);
90     IamExecutorInfo info = {};
91     auto ret = verifyHdi.GetExecutorInfo(info);
92     EXPECT_TRUE(info.executorRole == IamExecutorRole::VERIFIER);
93     EXPECT_TRUE(info.authType == IamAuthType::PIN);
94     EXPECT_TRUE(info.esl == IamExecutorSecureLevel::ESL0);
95     EXPECT_TRUE(ret == IamResultCode::SUCCESS);
96 }
97 
98 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_002, TestSize.Level0)
99 {
100     for (const auto &pair : RESULT_CODE_MAP) {
101         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
102         ASSERT_TRUE(executorProxy != nullptr);
103         EXPECT_CALL(*executorProxy, GetExecutorInfo(_))
104             .Times(Exactly(1))
__anon22e5e7820302(ExecutorInfo &info) 105             .WillOnce([&pair](ExecutorInfo &info) {
106                 info = {
107                     .executorRole = ExecutorRole::VERIFIER,
108                     .authType = AuthType::PIN,
109                     .esl = ExecutorSecureLevel::ESL0,
110                 };
111                 return static_cast<int32_t>(pair.first);
112             });
113         PinAuthVerifierHdi verifyHdi(executorProxy);
114         IamExecutorInfo info = {};
115         auto ret = verifyHdi.GetExecutorInfo(info);
116         EXPECT_TRUE(ret == pair.second);
117     }
118 }
119 
120 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_003, TestSize.Level0)
121 {
122     static const std::map<AuthType, pair<IamAuthType, IamResultCode>> data = {
123         {AuthType::PIN, {IamAuthType::PIN, IamResultCode::SUCCESS}},
124         {static_cast<AuthType>(AuthType::PIN + 1),
125             {IamAuthType::PIN, IamResultCode::GENERAL_ERROR}},
126         {static_cast<AuthType>(AuthType::PIN - 1),
127             {IamAuthType::PIN, IamResultCode::GENERAL_ERROR}},
128     };
129     for (const auto &pair : data) {
130         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
131         ASSERT_TRUE(executorProxy != nullptr);
132         EXPECT_CALL(*executorProxy, GetExecutorInfo(_))
133             .Times(Exactly(1))
__anon22e5e7820402(ExecutorInfo &info) 134             .WillOnce([&pair](ExecutorInfo &info) {
135                 info = {
136                     .executorRole = ExecutorRole::VERIFIER,
137                     .authType = pair.first,
138                     .esl = ExecutorSecureLevel::ESL0,
139                 };
140                 return HDF_SUCCESS;
141             });
142         PinAuthVerifierHdi verifyHdi(executorProxy);
143         IamExecutorInfo info = {};
144         auto ret = verifyHdi.GetExecutorInfo(info);
145         EXPECT_TRUE(ret == pair.second.second);
146         if (ret == IamResultCode::SUCCESS) {
147             EXPECT_TRUE(info.authType == pair.second.first);
148         }
149     }
150 }
151 
152 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_004, TestSize.Level0)
153 {
154     static const std::map<ExecutorRole, pair<IamExecutorRole, IamResultCode>> data = {
155         {ExecutorRole::COLLECTOR, {IamExecutorRole::COLLECTOR, IamResultCode::SUCCESS}},
156         {ExecutorRole::VERIFIER, {IamExecutorRole::VERIFIER, IamResultCode::SUCCESS}},
157         {ExecutorRole::ALL_IN_ONE, {IamExecutorRole::ALL_IN_ONE, IamResultCode::SUCCESS}},
158         {static_cast<ExecutorRole>(ExecutorRole::VERIFIER - 1),
159             {IamExecutorRole::VERIFIER, IamResultCode::GENERAL_ERROR}},
160         {static_cast<ExecutorRole>(ExecutorRole::VERIFIER + 1),
161             {IamExecutorRole::VERIFIER, IamResultCode::GENERAL_ERROR}},
162     };
163     for (const auto &pair : data) {
164         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
165         ASSERT_TRUE(executorProxy != nullptr);
166         EXPECT_CALL(*executorProxy, GetExecutorInfo(_))
167             .Times(Exactly(1))
__anon22e5e7820502(ExecutorInfo &info) 168             .WillOnce([&pair](ExecutorInfo &info) {
169                 info = {
170                     .executorRole = pair.first,
171                     .authType = AuthType::PIN,
172                     .esl = ExecutorSecureLevel::ESL0,
173                 };
174                 return HDF_SUCCESS;
175             });
176         PinAuthVerifierHdi verifyHdi(executorProxy);
177         IamExecutorInfo info = {};
178         auto ret = verifyHdi.GetExecutorInfo(info);
179         EXPECT_TRUE(ret == pair.second.second);
180         if (ret == IamResultCode::SUCCESS) {
181             EXPECT_TRUE(info.executorRole == pair.second.first);
182         }
183     }
184 }
185 
186 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_005, TestSize.Level0)
187 {
188     static const std::map<ExecutorSecureLevel, pair<IamExecutorSecureLevel, IamResultCode>> data =
189         {
190             {ExecutorSecureLevel::ESL0, {IamExecutorSecureLevel::ESL0, IamResultCode::SUCCESS}},
191             {ExecutorSecureLevel::ESL1, {IamExecutorSecureLevel::ESL1, IamResultCode::SUCCESS}},
192             {ExecutorSecureLevel::ESL2, {IamExecutorSecureLevel::ESL2, IamResultCode::SUCCESS}},
193             {ExecutorSecureLevel::ESL3, {IamExecutorSecureLevel::ESL3, IamResultCode::SUCCESS}},
194             {static_cast<ExecutorSecureLevel>(ExecutorSecureLevel::ESL0 - 1),
195                 {IamExecutorSecureLevel::ESL3, IamResultCode::GENERAL_ERROR}},
196             {static_cast<ExecutorSecureLevel>(ExecutorSecureLevel::ESL3 + 1),
197                 {IamExecutorSecureLevel::ESL3, IamResultCode::GENERAL_ERROR}},
198         };
199     for (const auto &pair : data) {
200         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
201         ASSERT_TRUE(executorProxy != nullptr);
202         EXPECT_CALL(*executorProxy, GetExecutorInfo(_))
203             .Times(Exactly(1))
__anon22e5e7820602(ExecutorInfo &info) 204             .WillOnce([&pair](ExecutorInfo &info) {
205                 info = {
206                     .executorRole = ExecutorRole::VERIFIER,
207                     .authType = AuthType::PIN,
208                     .esl = pair.first,
209                 };
210                 return HDF_SUCCESS;
211             });
212         PinAuthVerifierHdi verifyHdi(executorProxy);
213         IamExecutorInfo info = {};
214         auto ret = verifyHdi.GetExecutorInfo(info);
215         EXPECT_TRUE(ret == pair.second.second);
216         if (ret == IamResultCode::SUCCESS) {
217             EXPECT_TRUE(info.esl == pair.second.first);
218         }
219     }
220 }
221 
222 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_GetExecutorInfo_006, TestSize.Level0)
223 {
224     PinAuthVerifierHdi verifyHdi(nullptr);
225     IamExecutorInfo info = {};
226     auto ret = verifyHdi.GetExecutorInfo(info);
227     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
228 }
229 
230 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_OnRegisterFinish_001, TestSize.Level0)
231 {
232     for (const auto &pair : RESULT_CODE_MAP) {
233         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
234         ASSERT_TRUE(executorProxy != nullptr);
235         EXPECT_CALL(*executorProxy, OnRegisterFinish(_, _, _))
236             .Times(Exactly(1))
237             .WillOnce(
238                 [&pair](const std::vector<uint64_t> &templateIdList, const std::vector<uint8_t> &frameworkPublicKey,
__anon22e5e7820702(const std::vector<uint64_t> &templateIdList, const std::vector<uint8_t> &frameworkPublicKey, const std::vector<uint8_t> &extraInfo) 239                     const std::vector<uint8_t> &extraInfo) { return pair.first; });
240         PinAuthVerifierHdi verifyHdi(executorProxy);
241         auto ret =
242             verifyHdi.OnRegisterFinish(std::vector<uint64_t>(), std::vector<uint8_t>(), std::vector<uint8_t>());
243         EXPECT_TRUE(ret == pair.second);
244     }
245 }
246 
247 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_OnRegisterFinish_002, TestSize.Level0)
248 {
249     PinAuthVerifierHdi verifyHdi(nullptr);
250     auto ret = verifyHdi.OnRegisterFinish(std::vector<uint64_t>(), std::vector<uint8_t>(), std::vector<uint8_t>());
251     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
252 }
253 
254 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Authenticate_001, TestSize.Level0)
255 {
256     for (const auto &pair : RESULT_CODE_MAP) {
257         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
258         ASSERT_TRUE(executorProxy != nullptr);
259         EXPECT_CALL(*executorProxy, Authenticate(_, _, _, _)).Times(Exactly(1)).WillOnce([&pair](
260             uint64_t scheduleId, const std::vector<uint64_t>& templateIdList, const std::vector<uint8_t> &extraInfo,
__anon22e5e7820802( uint64_t scheduleId, const std::vector<uint64_t>& templateIdList, const std::vector<uint8_t> &extraInfo, const sptr<IExecutorCallback> &callbackObj) 261             const sptr<IExecutorCallback> &callbackObj) { return pair.first; });
262         auto verifyHdi = MakeShared<PinAuthVerifierHdi>(executorProxy);
263         ASSERT_TRUE(verifyHdi != nullptr);
264         auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
265         ASSERT_TRUE(executeCallback != nullptr);
266         const std::vector<uint64_t> templateIdList = {1, 2};
267         auto ret = verifyHdi->Authenticate(0,
268             UserAuth::AuthenticateParam{0, templateIdList, std::vector<uint8_t>()}, executeCallback);
269         EXPECT_TRUE(ret == pair.second);
270     }
271 }
272 
273 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Authenticate_002, TestSize.Level0)
274 {
275     auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
276     ASSERT_TRUE(executorProxy != nullptr);
277     auto verifyHdi = MakeShared<PinAuthVerifierHdi>(executorProxy);
278     auto ret = verifyHdi->Authenticate(0,
279         UserAuth::AuthenticateParam{0, std::vector<uint64_t>(), std::vector<uint8_t>()}, nullptr);
280     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
281 }
282 
283 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Authenticate_003, TestSize.Level0)
284 {
285     auto verifyHdi = MakeShared<PinAuthVerifierHdi>(nullptr);
286     auto executeCallback = MakeShared<UserIam::UserAuth::MockIExecuteCallback>();
287     ASSERT_TRUE(executeCallback != nullptr);
288     auto ret = verifyHdi->Authenticate(0,
289         UserAuth::AuthenticateParam{0, std::vector<uint64_t>(), std::vector<uint8_t>()}, executeCallback);
290     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
291 }
292 
293 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Authenticate_004, TestSize.Level0)
294 {
295     PinAuthVerifierHdi verifyHdi(nullptr);
296     auto ret = verifyHdi.Authenticate(0,
297         UserAuth::AuthenticateParam{0, std::vector<uint64_t>(), std::vector<uint8_t>()}, nullptr);
298     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
299 }
300 
301 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Cancel_001, TestSize.Level0)
302 {
303     for (const auto &pair : RESULT_CODE_MAP) {
304         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
305         ASSERT_TRUE(executorProxy != nullptr);
__anon22e5e7820902(uint64_t scheduleId) 306         EXPECT_CALL(*executorProxy, Cancel(_)).Times(Exactly(1)).WillOnce([&pair](uint64_t scheduleId) {
307             return pair.first;
308         });
309         PinAuthVerifierHdi verifyHdi(executorProxy);
310         auto ret = verifyHdi.Cancel(0);
311         EXPECT_TRUE(ret == pair.second);
312     }
313 }
314 
315 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_Cancel_002, TestSize.Level0)
316 {
317     PinAuthVerifierHdi verifyHdi(nullptr);
318     auto ret = verifyHdi.Cancel(0);
319     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
320 }
321 
322 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_SendMessage_001, TestSize.Level0)
323 {
324     auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
325     ASSERT_TRUE(executorProxy != nullptr);
326     PinAuthVerifierHdi verifyHdi(executorProxy);
327     std::vector<uint8_t> data;
328     auto ret = verifyHdi.SendMessage(1, 1, data);
329     EXPECT_TRUE(ret == IamResultCode::SUCCESS);
330 }
331 
332 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_SendMessage_002, TestSize.Level0)
333 {
334     PinAuthVerifierHdi verifyHdi(nullptr);
335     std::vector<uint8_t> data;
336     auto ret = verifyHdi.SendMessage(1, 1, data);
337     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
338 }
339 
340 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_NotifyCollectorReady_001, TestSize.Level0)
341 {
342     for (const auto &pair : RESULT_CODE_MAP) {
343         auto executorProxy = new (std::nothrow) MockIVerifyExecutor();
344         ASSERT_TRUE(executorProxy != nullptr);
__anon22e5e7820a02(uint64_t scheduleId) 345         EXPECT_CALL(*executorProxy, NotifyCollectorReady(_)).Times(Exactly(1)).WillOnce([&pair](uint64_t scheduleId) {
346             return pair.first;
347         });
348         PinAuthVerifierHdi verifyHdi(executorProxy);
349         auto ret = verifyHdi.NotifyCollectorReady(0);
350         EXPECT_TRUE(ret == pair.second);
351     }
352 }
353 
354 HWTEST_F(PinAuthVerifierHdiUnitTest, PinAuthVerifierExecutorHdi_NotifyCollectorReady_002, TestSize.Level0)
355 {
356     PinAuthVerifierHdi verifyHdi(nullptr);
357     auto ret = verifyHdi.NotifyCollectorReady(0);
358     EXPECT_TRUE(ret == IamResultCode::GENERAL_ERROR);
359 }
360 } // namespace PinAuth
361 } // namespace UserIam
362 } // namespace OHOS
363