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