1 /*
2  * Copyright (c) 2022-2023 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 "securec.h"
19 
20 #include "adaptor_time.h"
21 #include "buffer.h"
22 #include "coauth.h"
23 #include "defines.h"
24 #include "executor_message.h"
25 #include "idm_database.h"
26 #include "idm_session.h"
27 #include "pool.h"
28 #include "user_idm_funcs.h"
29 
30 extern "C" {
31     extern struct SessionInfo {
32         int32_t userId;
33         uint32_t authType;
34         uint64_t time;
35         uint64_t validAuthTokenTime;
36         uint8_t challenge[CHALLENGE_LEN];
37         uint64_t scheduleId;
38         bool isUpdate;
39         bool isScheduleValid;
40     } *g_session;
41     extern LinkedList *g_poolList;
42     extern LinkedList *g_userInfoList;
43     extern LinkedList *g_scheduleList;
44     extern CoAuthSchedule *GenerateIdmSchedule(const PermissionCheckParam *param);
45     extern int32_t GetCredentialInfoFromSchedule(const ExecutorResultInfo *executorInfo,
46         CredentialInfoHal *credentialInfo, const CoAuthSchedule *schedule);
47     extern int32_t GetDeletedCredential(int32_t userId, CredentialInfoHal *deletedCredential);
48     extern int32_t CheckResultValid(uint64_t scheduleId, int32_t userId);
49 }
50 
51 namespace OHOS {
52 namespace UserIam {
53 namespace UserAuth {
54 using namespace testing;
55 using namespace testing::ext;
56 
57 class UserIdmFuncsTest : public testing::Test {
58 public:
SetUpTestCase()59     static void SetUpTestCase() {};
60 
TearDownTestCase()61     static void TearDownTestCase() {};
62 
SetUp()63     void SetUp() {};
64 
TearDown()65     void TearDown() {};
66 };
67 
68 HWTEST_F(UserIdmFuncsTest, TestGenerateIdmSchedule_001, TestSize.Level0)
69 {
70     PermissionCheckParam param = {};
71     constexpr uint32_t executorSensorHint = 10;
72     param.executorSensorHint = executorSensorHint;
73     EXPECT_EQ(GenerateIdmSchedule(&param), nullptr);
74 }
75 
76 HWTEST_F(UserIdmFuncsTest, TestGenerateIdmSchedule_002, TestSize.Level0)
77 {
78     InitResourcePool();
79     EXPECT_NE(g_poolList, nullptr);
80     constexpr uint32_t executorSensorHint = 10;
81     ExecutorInfoHal info = {};
82     info.authType = PIN_AUTH;
83     info.executorSensorHint = executorSensorHint;
84     info.executorRole = COLLECTOR;
85     g_poolList->insert(g_poolList, static_cast<void *>(&info));
86     PermissionCheckParam param = {};
87     param.authType = PIN_AUTH;
88     param.executorSensorHint = executorSensorHint;
89     EXPECT_EQ(GenerateIdmSchedule(&param), nullptr);
90     g_poolList = nullptr;
91 }
92 
93 HWTEST_F(UserIdmFuncsTest, TestCheckEnrollPermission_001, TestSize.Level0)
94 {
95     PermissionCheckParam param = {};
96     EXPECT_EQ(CheckEnrollPermission(param, nullptr), RESULT_BAD_PARAM);
97 }
98 
99 HWTEST_F(UserIdmFuncsTest, TestCheckEnrollPermission_002, TestSize.Level0)
100 {
101     constexpr int32_t userId = 32156;
102     struct SessionInfo session = {};
103     session.userId = userId;
104     session.time = GetSystemTime();
105     g_session = &session;
106 
107     g_userInfoList = CreateLinkedList(DestroyUserInfoNode);
108     EXPECT_NE(g_userInfoList, nullptr);
109     PermissionCheckParam param = {};
110     param.authType = FACE_AUTH;
111     uint64_t scheduleId = 0;
112     EXPECT_EQ(CheckEnrollPermission(param, &scheduleId), RESULT_GENERAL_ERROR);
113     param.userId = userId;
114     EXPECT_EQ(CheckEnrollPermission(param, &scheduleId), RESULT_VERIFY_TOKEN_FAIL);
115     DestroyLinkedList(g_userInfoList);
116     g_userInfoList = nullptr;
117     g_session = nullptr;
118 }
119 
120 HWTEST_F(UserIdmFuncsTest, TestCheckUpdatePermission_001, TestSize.Level0)
121 {
122     PermissionCheckParam param = {};
123     param.authType = FACE_AUTH;
124     EXPECT_EQ(CheckUpdatePermission(param, nullptr), RESULT_BAD_PARAM);
125     uint64_t scheduleId = 0;
126     EXPECT_EQ(CheckUpdatePermission(param, &scheduleId), RESULT_BAD_PARAM);
127     param.authType = PIN_AUTH;
128     EXPECT_EQ(CheckUpdatePermission(param, &scheduleId), RESULT_NEED_INIT);
129 }
130 
131 HWTEST_F(UserIdmFuncsTest, TestCheckUpdatePermission_002, TestSize.Level0)
132 {
133     constexpr int32_t userId = 32156;
134     constexpr uint32_t excutorSensorHint1 = 10;
135     constexpr uint32_t excutorSensorHint2 = 20;
136     struct SessionInfo session = {};
137     session.userId = userId;
138     session.time = GetSystemTime();
139     g_session = &session;
140     g_userInfoList = CreateLinkedList(DestroyUserInfoNode);
141     EXPECT_NE(g_userInfoList, nullptr);
142 
143     PermissionCheckParam param = {};
144     param.authType = PIN_AUTH;
145     param.userId = userId;
146     uint64_t scheduleId = 0;
147     EXPECT_EQ(CheckUpdatePermission(param, &scheduleId), RESULT_SUCCESS);
148     UserInfo userInfo = {};
149     userInfo.userId = userId;
150     userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode);
151     EXPECT_NE(userInfo.credentialInfoList, nullptr);
152     CredentialInfoHal credInfo = {};
153     credInfo.authType = PIN_AUTH;
154     credInfo.executorSensorHint = excutorSensorHint2;
155     userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credInfo));
156     g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo));
157     param.executorSensorHint = excutorSensorHint1;
158     EXPECT_EQ(CheckUpdatePermission(param, &scheduleId), RESULT_VERIFY_TOKEN_FAIL);
159     g_userInfoList = nullptr;
160     g_session = nullptr;
161 }
162 
163 HWTEST_F(UserIdmFuncsTest, TestGetCredentialInfoFromSchedule, TestSize.Level0)
164 {
165     g_session = nullptr;
166     ExecutorResultInfo resultInfo = {};
167     CredentialInfoHal credInfo = {};
168     CoAuthSchedule scheduleInfo = {};
169     EXPECT_EQ(GetCredentialInfoFromSchedule(&resultInfo, &credInfo, &scheduleInfo), RESULT_GENERAL_ERROR);
170 
171     constexpr int32_t userId = 32158;
172     struct SessionInfo session = {};
173     session.userId = userId;
174     session.isScheduleValid = true;
175     session.scheduleId = 10;
176     session.authType = FACE_AUTH;
177     session.time = UINT64_MAX;
178     g_session = &session;
179 
180     resultInfo.scheduleId = 311157;
181     EXPECT_EQ(GetCredentialInfoFromSchedule(&resultInfo, &credInfo, &scheduleInfo), RESULT_GENERAL_ERROR);
182     resultInfo.scheduleId = 10;
183     EXPECT_EQ(GetCredentialInfoFromSchedule(&resultInfo, &credInfo, &scheduleInfo), RESULT_GENERAL_ERROR);
184 
185     session.time = GetSystemTime();
186     g_scheduleList = nullptr;
187     EXPECT_EQ(GetCredentialInfoFromSchedule(&resultInfo, &credInfo, &scheduleInfo), RESULT_SUCCESS);
188     g_session = nullptr;
189 }
190 
191 HWTEST_F(UserIdmFuncsTest, TestAddCredentialFunc, TestSize.Level0)
192 {
193     constexpr int32_t userId1 = 21345;
194     constexpr int32_t userId2 = 1122;
195     EXPECT_EQ(AddCredentialFunc(userId1, nullptr, nullptr, nullptr, nullptr), RESULT_BAD_PARAM);
196     Buffer *scheduleResult = CreateBufferBySize(20);
197     uint64_t credentialId = 0;
198     Buffer *rootSecret = nullptr;
199     Buffer *authToken = nullptr;
200     EXPECT_EQ(AddCredentialFunc(userId1, scheduleResult, &credentialId, &rootSecret, &authToken), RESULT_UNKNOWN);
201     struct SessionInfo session = {};
202     session.userId = userId2;
203     g_session = &session;
204     EXPECT_EQ(AddCredentialFunc(userId1, scheduleResult, &credentialId, &rootSecret, &authToken), RESULT_UNKNOWN);
205     g_session = nullptr;
206 }
207 
208 HWTEST_F(UserIdmFuncsTest, TestDeleteCredentialFunc, TestSize.Level0)
209 {
210     CredentialDeleteParam param = {};
211     EXPECT_EQ(DeleteCredentialFunc(param, nullptr), RESULT_BAD_PARAM);
212 
213     CredentialInfoHal credInfo = {};
214     UserAuthTokenHal token = {};
215     token.tokenDataPlain.authType = 4;
216     EXPECT_EQ(memcpy_s(param.token, sizeof(UserAuthTokenHal), &token, sizeof(UserAuthTokenHal)), EOK);
217     EXPECT_EQ(DeleteCredentialFunc(param, &credInfo), RESULT_VERIFY_TOKEN_FAIL);
218 }
219 
220 HWTEST_F(UserIdmFuncsTest, TestQueryCredentialFunc, TestSize.Level0)
221 {
222     EXPECT_EQ(QueryCredentialFunc(0, 0, nullptr), RESULT_BAD_PARAM);
223     LinkedList *creds = nullptr;
224     g_userInfoList = nullptr;
225     EXPECT_EQ(QueryCredentialFunc(0, 0, &creds), RESULT_UNKNOWN);
226 }
227 
228 HWTEST_F(UserIdmFuncsTest, TestGetUserInfoFunc, TestSize.Level0)
229 {
230     EXPECT_EQ(GetUserInfoFunc(0, nullptr, nullptr, nullptr, nullptr), RESULT_BAD_PARAM);
231 }
232 
233 HWTEST_F(UserIdmFuncsTest, TestGetDeletedCredential, TestSize.Level0)
234 {
235     g_userInfoList = nullptr;
236     constexpr int32_t userId = 2156;
237     CredentialInfoHal deletedCredInfo = {};
238     EXPECT_EQ(GetDeletedCredential(userId, &deletedCredInfo), RESULT_UNKNOWN);
239 
240     g_userInfoList = CreateLinkedList(DestroyUserInfoNode);
241     EXPECT_NE(g_userInfoList, nullptr);
242     EXPECT_EQ(GetDeletedCredential(userId, &deletedCredInfo), RESULT_UNKNOWN);
243 
244     UserInfo userInfo = {};
245     userInfo.userId = userId;
246     userInfo.credentialInfoList = CreateLinkedList(DestroyCredentialNode);
247     EXPECT_NE(userInfo.credentialInfoList, nullptr);
248     CredentialInfoHal credInfo = {};
249     credInfo.authType = 1;
250     userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credInfo));
251     userInfo.credentialInfoList->insert(userInfo.credentialInfoList, static_cast<void *>(&credInfo));
252     g_userInfoList->insert(g_userInfoList, static_cast<void *>(&userInfo));
253     EXPECT_EQ(GetDeletedCredential(userId, &deletedCredInfo), RESULT_UNKNOWN);
254 }
255 
256 HWTEST_F(UserIdmFuncsTest, TestCheckResultValid, TestSize.Level0)
257 {
258     g_session = nullptr;
259     constexpr uint64_t scheduleId = 10;
260     constexpr int32_t userId = 2112;
261     EXPECT_EQ(CheckResultValid(scheduleId, userId), RESULT_GENERAL_ERROR);
262 
263     struct SessionInfo session = {};
264     session.userId = 1122;
265     session.scheduleId = 20;
266     session.authType = FACE_AUTH;
267     session.isScheduleValid = true;
268     session.time = UINT64_MAX;
269     g_session = &session;
270     EXPECT_EQ(CheckResultValid(scheduleId, userId), RESULT_GENERAL_ERROR);
271 
272     session.scheduleId = scheduleId;
273     EXPECT_EQ(CheckResultValid(scheduleId, userId), RESULT_GENERAL_ERROR);
274 
275     session.time = GetSystemTime();
276     EXPECT_EQ(CheckResultValid(scheduleId, userId), RESULT_REACH_LIMIT);
277 
278     session.userId = userId;
279     EXPECT_EQ(CheckResultValid(scheduleId, userId), RESULT_UNKNOWN);
280 }
281 
282 HWTEST_F(UserIdmFuncsTest, TestUpdateCredentialFunc, TestSize.Level0)
283 {
284     EXPECT_EQ(UpdateCredentialFunc(0, nullptr, nullptr), RESULT_BAD_PARAM);
285 
286     constexpr uint32_t bufferSize = 10;
287     Buffer *scheduleResult = CreateBufferBySize(bufferSize);
288     UpdateCredentialOutput output = {};
289     EXPECT_EQ(UpdateCredentialFunc(0, scheduleResult, &output), RESULT_UNKNOWN);
290 }
291 } // namespace UserAuth
292 } // namespace UserIam
293 } // namespace OHOS
294