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
HWTEST_F(UserIdmFuncsTest, TestGenerateIdmSchedule_001, TestSize.Level0)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(¶m), nullptr);
74 }
75
HWTEST_F(UserIdmFuncsTest, TestGenerateIdmSchedule_002, TestSize.Level0)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(¶m), nullptr);
90 g_poolList = nullptr;
91 }
92
HWTEST_F(UserIdmFuncsTest, TestCheckEnrollPermission_001, TestSize.Level0)93 HWTEST_F(UserIdmFuncsTest, TestCheckEnrollPermission_001, TestSize.Level0)
94 {
95 PermissionCheckParam param = {};
96 EXPECT_EQ(CheckEnrollPermission(param, nullptr), RESULT_BAD_PARAM);
97 }
98
HWTEST_F(UserIdmFuncsTest, TestCheckEnrollPermission_002, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestCheckUpdatePermission_001, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestCheckUpdatePermission_002, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestGetCredentialInfoFromSchedule, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestAddCredentialFunc, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestDeleteCredentialFunc, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestQueryCredentialFunc, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestGetUserInfoFunc, TestSize.Level0)228 HWTEST_F(UserIdmFuncsTest, TestGetUserInfoFunc, TestSize.Level0)
229 {
230 EXPECT_EQ(GetUserInfoFunc(0, nullptr, nullptr, nullptr, nullptr), RESULT_BAD_PARAM);
231 }
232
HWTEST_F(UserIdmFuncsTest, TestGetDeletedCredential, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestCheckResultValid, TestSize.Level0)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
HWTEST_F(UserIdmFuncsTest, TestUpdateCredentialFunc, TestSize.Level0)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