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_memory.h"
21 #include "coauth.h"
22 
23 extern "C" {
24     extern LinkedList *g_poolList;
25     extern LinkedList *g_scheduleList;
26     extern bool IsScheduleMatch(const void *data, const void *condition);
27     extern bool IsScheduleIdDuplicate(uint64_t scheduleId);
28     extern ResultCode GenerateValidScheduleId(uint64_t *scheduleId);
29     extern ResultCode MountExecutorOnce(const LinkedList *executors, CoAuthSchedule *coAuthSchedule,
30         uint32_t sensorHint, uint32_t executorRole, Uint8Array deviceUdid);
31     extern void DestroyExecutorInfo(void *data);
32     extern ResultCode MountExecutor(const ScheduleParam *param, CoAuthSchedule *coAuthSchedule);
33 }
34 
35 namespace OHOS {
36 namespace UserIam {
37 namespace UserAuth {
38 using namespace testing;
39 using namespace testing::ext;
40 
41 class CoAuthTest : public testing::Test {
42 public:
SetUpTestCase()43     static void SetUpTestCase() {};
44 
TearDownTestCase()45     static void TearDownTestCase() {};
46 
SetUp()47     void SetUp() {};
48 
TearDown()49     void TearDown() {};
50 };
51 
HWTEST_F(CoAuthTest, TestDestroyScheduleNode, TestSize.Level0)52 HWTEST_F(CoAuthTest, TestDestroyScheduleNode, TestSize.Level0)
53 {
54     DestroyScheduleNode(nullptr);
55     CoAuthSchedule *schedule = (CoAuthSchedule *)Malloc(sizeof(CoAuthSchedule));
56     EXPECT_NE(schedule, nullptr);
57     ASSERT_NE(schedule, nullptr);
58     (void)memset_s(schedule, sizeof(CoAuthSchedule), 0, sizeof(CoAuthSchedule));
59     schedule->templateIds.data = (uint64_t *)Malloc(sizeof(uint64_t));
60     EXPECT_NE(schedule->templateIds.data, nullptr);
61     ASSERT_NE(schedule->templateIds.data, nullptr);
62     schedule->templateIds.len = 1;
63     DestroyScheduleNode(schedule);
64 }
65 
HWTEST_F(CoAuthTest, TestCopyCoAuthSchedule, TestSize.Level0)66 HWTEST_F(CoAuthTest, TestCopyCoAuthSchedule, TestSize.Level0)
67 {
68     EXPECT_EQ(CopyCoAuthSchedule(nullptr), nullptr);
69     CoAuthSchedule schedule = {};
70     schedule.templateIds.len = 1;
71     schedule.templateIds.data = nullptr;
72     EXPECT_EQ(CopyCoAuthSchedule(&schedule), nullptr);
73 }
74 
HWTEST_F(CoAuthTest, TestDestroyCoAuthSchedule, TestSize.Level0)75 HWTEST_F(CoAuthTest, TestDestroyCoAuthSchedule, TestSize.Level0)
76 {
77     DestroyCoAuthSchedule(nullptr);
78     CoAuthSchedule *schedule = (CoAuthSchedule *)Malloc(sizeof(CoAuthSchedule));
79     EXPECT_NE(schedule, nullptr);
80     ASSERT_NE(schedule, nullptr);
81     (void)memset_s(schedule, sizeof(CoAuthSchedule), 0, sizeof(CoAuthSchedule));
82     schedule->templateIds.data = (uint64_t *)Malloc(sizeof(uint64_t));
83     EXPECT_NE(schedule->templateIds.data, nullptr);
84     ASSERT_NE(schedule->templateIds.data, nullptr);
85     schedule->templateIds.len = 1;
86     DestroyCoAuthSchedule(schedule);
87 }
88 
HWTEST_F(CoAuthTest, TestInitCoAuth, TestSize.Level0)89 HWTEST_F(CoAuthTest, TestInitCoAuth, TestSize.Level0)
90 {
91     InitCoAuth();
92     EXPECT_EQ(InitCoAuth(), RESULT_SUCCESS);
93     DestoryCoAuth();
94 }
95 
HWTEST_F(CoAuthTest, TestAddCoAuthSchedule, TestSize.Level0)96 HWTEST_F(CoAuthTest, TestAddCoAuthSchedule, TestSize.Level0)
97 {
98     g_scheduleList = nullptr;
99     EXPECT_EQ(AddCoAuthSchedule(nullptr), RESULT_NEED_INIT);
100     InitCoAuth();
101     EXPECT_EQ(AddCoAuthSchedule(nullptr), RESULT_BAD_PARAM);
102     CoAuthSchedule schedule = {};
103     schedule.templateIds.len = 1;
104     schedule.templateIds.data = nullptr;
105     EXPECT_EQ(AddCoAuthSchedule(&schedule), RESULT_NO_MEMORY);
106     DestoryCoAuth();
107 }
108 
HWTEST_F(CoAuthTest, TestIsScheduleMatch, TestSize.Level0)109 HWTEST_F(CoAuthTest, TestIsScheduleMatch, TestSize.Level0)
110 {
111     EXPECT_FALSE(IsScheduleMatch(nullptr, nullptr));
112 }
113 
HWTEST_F(CoAuthTest, TestRemoveCoAuthSchedule, TestSize.Level0)114 HWTEST_F(CoAuthTest, TestRemoveCoAuthSchedule, TestSize.Level0)
115 {
116     g_scheduleList = nullptr;
117     constexpr uint64_t scheduleId = 32565;
118     EXPECT_EQ(RemoveCoAuthSchedule(scheduleId), RESULT_NEED_INIT);
119 }
120 
HWTEST_F(CoAuthTest, TestGetCoAuthSchedule, TestSize.Level0)121 HWTEST_F(CoAuthTest, TestGetCoAuthSchedule, TestSize.Level0)
122 {
123     g_scheduleList = nullptr;
124     constexpr uint64_t scheduleId1 = 32565;
125     constexpr uint64_t scheduleId2 = 3200;
126     EXPECT_EQ(GetCoAuthSchedule(scheduleId1), nullptr);
127     InitCoAuth();
128     CoAuthSchedule schedule1 = {};
129     schedule1.scheduleId = scheduleId1;
130     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule1));
131     CoAuthSchedule schedule2 = {};
132     schedule2.scheduleId = scheduleId2;
133     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule2));
134     g_scheduleList->insert(g_scheduleList, nullptr);
135     EXPECT_NE(GetCoAuthSchedule(scheduleId1), nullptr);
136 }
137 
HWTEST_F(CoAuthTest, TestIsScheduleIdDuplicate, TestSize.Level0)138 HWTEST_F(CoAuthTest, TestIsScheduleIdDuplicate, TestSize.Level0)
139 {
140     g_scheduleList = nullptr;
141     constexpr uint64_t scheduleId1 = 36163;
142     constexpr uint64_t scheduleId2 = 3200;
143     InitCoAuth();
144     EXPECT_FALSE(IsScheduleIdDuplicate(scheduleId1));
145     CoAuthSchedule schedule1 = {};
146     schedule1.scheduleId = scheduleId1;
147     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule1));
148     CoAuthSchedule schedule2 = {};
149     schedule2.scheduleId = scheduleId2;
150     g_scheduleList->insert(g_scheduleList, static_cast<void *>(&schedule2));
151     g_scheduleList->insert(g_scheduleList, nullptr);
152     EXPECT_TRUE(IsScheduleIdDuplicate(scheduleId1));
153 }
154 
HWTEST_F(CoAuthTest, TestGenerateValidScheduleId, TestSize.Level0)155 HWTEST_F(CoAuthTest, TestGenerateValidScheduleId, TestSize.Level0)
156 {
157     g_scheduleList = nullptr;
158     uint64_t scheduleId = 0;
159     EXPECT_EQ(GenerateValidScheduleId(&scheduleId), RESULT_BAD_PARAM);
160 }
161 
HWTEST_F(CoAuthTest, TestMountExecutorOnce_001, TestSize.Level0)162 HWTEST_F(CoAuthTest, TestMountExecutorOnce_001, TestSize.Level0)
163 {
164     LinkedList *executor = CreateLinkedList(DestroyExecutorInfo);
165     CoAuthSchedule schedule = {};
166     constexpr uint32_t sensorHint = 3565;
167     constexpr uint32_t excutorRole = 6636;
168     uint8_t deviceUdidBuffer[64] = { 0 };
169     Uint8Array deviceUdid = { deviceUdidBuffer, 64 };
170     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, excutorRole, deviceUdid), RESULT_NOT_FOUND);
171     executor->insert(executor, nullptr);
172     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, excutorRole, deviceUdid), RESULT_UNKNOWN);
173 }
174 
HWTEST_F(CoAuthTest, TestMountExecutorOnce_002, TestSize.Level0)175 HWTEST_F(CoAuthTest, TestMountExecutorOnce_002, TestSize.Level0)
176 {
177     LinkedList *executor = CreateLinkedList(DestroyExecutorInfo);
178     CoAuthSchedule schedule = {};
179     constexpr uint32_t excutorSensorHint1 = 10;
180     constexpr uint32_t excutorSensorHint2 = 20;
181     constexpr uint32_t excutorRole1 = 6636;
182     constexpr uint32_t excutorRole2 = 6110;
183     uint32_t sensorHint = 0;
184     uint32_t executorRole = excutorRole1;
185     ExecutorInfoHal info1 = {};
186     info1.executorRole = excutorRole1;
187     info1.executorSensorHint = excutorSensorHint1;
188     executor->insert(executor, static_cast<void *>(&info1));
189     ExecutorInfoHal info2 = {};
190     info2.executorRole = excutorRole1;
191     info2.executorSensorHint = excutorSensorHint2;
192     executor->insert(executor, static_cast<void *>(&info2));
193     ExecutorInfoHal info3 = {};
194     info3.executorRole = excutorRole2;
195     executor->insert(executor, static_cast<void *>(&info3));
196     uint8_t deviceUdidBuffer[64] = { 0 };
197     Uint8Array deviceUdid = { deviceUdidBuffer, 64 };
198     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole, deviceUdid), RESULT_SUCCESS);
199     sensorHint = 10;
200     EXPECT_EQ(MountExecutorOnce(executor, &schedule, sensorHint, executorRole, deviceUdid), RESULT_SUCCESS);
201 }
202 
HWTEST_F(CoAuthTest, TestMountExecutor_001, TestSize.Level0)203 HWTEST_F(CoAuthTest, TestMountExecutor_001, TestSize.Level0)
204 {
205     constexpr uint32_t collectorSensorHint = 1012;
206     g_poolList = nullptr;
207     ScheduleParam param = {};
208     param.collectorSensorHint = collectorSensorHint;
209     CoAuthSchedule schedule = {};
210     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_UNKNOWN);
211     InitResourcePool();
212     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
213     DestroyResourcePool();
214 }
215 
HWTEST_F(CoAuthTest, TestMountExecutor_002, TestSize.Level0)216 HWTEST_F(CoAuthTest, TestMountExecutor_002, TestSize.Level0)
217 {
218     constexpr uint32_t verifierSensorHint = 1024;
219     InitResourcePool();
220     ScheduleParam param = {};
221     param.collectorSensorHint = 0;
222     param.verifierSensorHint = 0;
223     CoAuthSchedule schedule = {};
224     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
225     param.verifierSensorHint = verifierSensorHint;
226     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
227     DestroyResourcePool();
228 }
229 
HWTEST_F(CoAuthTest, TestMountExecutor_003, TestSize.Level0)230 HWTEST_F(CoAuthTest, TestMountExecutor_003, TestSize.Level0)
231 {
232     constexpr uint32_t collectorSensorHint = 10;
233     constexpr uint32_t verifierSensorHint_1 = 10;
234     constexpr uint32_t verifierSensorHint_2 = 20;
235     InitResourcePool();
236     ScheduleParam param = {};
237     param.collectorSensorHint = 0;
238     CoAuthSchedule schedule = {};
239     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
240     param.collectorSensorHint = collectorSensorHint;
241     param.verifierSensorHint = 0;
242     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
243     param.verifierSensorHint = verifierSensorHint_1;
244     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
245     param.verifierSensorHint = verifierSensorHint_2;
246     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
247     DestroyResourcePool();
248 }
249 
HWTEST_F(CoAuthTest, TestMountExecutor_004, TestSize.Level0)250 HWTEST_F(CoAuthTest, TestMountExecutor_004, TestSize.Level0)
251 {
252     constexpr uint32_t authType = 1;
253     constexpr uint32_t excutorRole = 3;
254     constexpr uint32_t executorSensorHint = 10;
255     g_poolList = nullptr;
256     InitResourcePool();
257     ExecutorInfoHal info = {};
258     info.authType = authType;
259     info.executorRole = excutorRole;
260     info.executorSensorHint = executorSensorHint;
261     g_poolList->insert(g_poolList, static_cast<void *>(&info));
262 
263     ScheduleParam param = {};
264     param.authType = authType;
265     param.collectorSensorHint = 0;
266     param.verifierSensorHint = 0;
267     CoAuthSchedule schedule = {};
268     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_SUCCESS);
269 }
270 
HWTEST_F(CoAuthTest, TestMountExecutor_005, TestSize.Level0)271 HWTEST_F(CoAuthTest, TestMountExecutor_005, TestSize.Level0)
272 {
273     constexpr uint32_t authType = 1;
274     constexpr uint32_t excutorRole1 = 3;
275     constexpr uint32_t executorSensorHint_1 = 10;
276     constexpr uint32_t excutorRole2 = 101;
277     constexpr uint32_t executorSensorHint_2 = 201;
278     g_poolList = nullptr;
279     InitResourcePool();
280     ExecutorInfoHal info = {};
281     info.authType = authType;
282     info.executorRole = excutorRole1;
283     info.executorSensorHint = executorSensorHint_1;
284     g_poolList->insert(g_poolList, static_cast<void *>(&info));
285 
286     ScheduleParam param = {};
287     param.authType = authType;
288     param.collectorSensorHint = excutorRole2;
289     param.verifierSensorHint = executorSensorHint_2;
290     param.scheduleMode = SCHEDULE_MODE_IDENTIFY;
291     CoAuthSchedule schedule = {};
292     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_GENERAL_ERROR);
293     param.scheduleMode = SCHEDULE_MODE_AUTH;
294     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
295     param.verifierSensorHint = executorSensorHint_1;
296     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_NOT_FOUND);
297     param.collectorSensorHint = executorSensorHint_1;
298     EXPECT_EQ(MountExecutor(&param, &schedule), RESULT_SUCCESS);
299 }
300 
HWTEST_F(CoAuthTest, TestGetScheduleVerifierSensorHint_001, TestSize.Level0)301 HWTEST_F(CoAuthTest, TestGetScheduleVerifierSensorHint_001, TestSize.Level0)
302 {
303     constexpr uint32_t executorSensorHint = 10;
304     EXPECT_EQ(GetScheduleVerifierSensorHint(nullptr), INVALID_SENSOR_HINT);
305     CoAuthSchedule schedule = {};
306     ExecutorInfoHal info = {};
307     info.executorSensorHint = executorSensorHint;
308     info.executorRole = VERIFIER;
309     schedule.executorSize = 1;
310     schedule.executors[0] = info;
311     EXPECT_EQ(GetScheduleVerifierSensorHint(&schedule), info.executorSensorHint);
312 }
313 
HWTEST_F(CoAuthTest, TestGetScheduleVerifierSensorHint_002, TestSize.Level0)314 HWTEST_F(CoAuthTest, TestGetScheduleVerifierSensorHint_002, TestSize.Level0)
315 {
316     constexpr uint32_t executorSensorHint = 10;
317     constexpr uint32_t excutorSize = 1;
318     CoAuthSchedule schedule = {};
319     ExecutorInfoHal info = {};
320     info.executorSensorHint = executorSensorHint;
321     info.executorRole = COLLECTOR;
322     schedule.executorSize = excutorSize;
323     schedule.executors[0] = info;
324     EXPECT_EQ(GetScheduleVerifierSensorHint(&schedule), INVALID_SENSOR_HINT);
325     schedule.executors[0].executorRole = ALL_IN_ONE;
326     EXPECT_EQ(GetScheduleVerifierSensorHint(&schedule), info.executorSensorHint);
327 }
328 
HWTEST_F(CoAuthTest, TestGenerateSchedule_001, TestSize.Level0)329 HWTEST_F(CoAuthTest, TestGenerateSchedule_001, TestSize.Level0)
330 {
331     EXPECT_EQ(GenerateSchedule(nullptr), nullptr);
332     g_scheduleList = nullptr;
333     ScheduleParam param = {};
334     EXPECT_EQ(GenerateSchedule(&param), nullptr);
335 }
336 
HWTEST_F(CoAuthTest, TestGenerateSchedule_002, TestSize.Level0)337 HWTEST_F(CoAuthTest, TestGenerateSchedule_002, TestSize.Level0)
338 {
339     constexpr uint32_t arrayLen = 1;
340     constexpr uint32_t data = 1024;
341     g_scheduleList = nullptr;
342     InitCoAuth();
343     ScheduleParam param = {};
344     param.templateIds = nullptr;
345     EXPECT_EQ(GenerateSchedule(&param), nullptr);
346     Uint64Array array = {};
347     array.len = arrayLen;
348     array.data = nullptr;
349     param.templateIds = &array;
350     EXPECT_EQ(GenerateSchedule(&param), nullptr);
351     uint64_t temp = data;
352     array.data = &temp;
353     EXPECT_EQ(GenerateSchedule(&param), nullptr);
354 }
355 
HWTEST_F(CoAuthTest, TestIsTemplateArraysValid, TestSize.Level0)356 HWTEST_F(CoAuthTest, TestIsTemplateArraysValid, TestSize.Level0)
357 {
358     constexpr uint32_t arrayLen = 200;
359     constexpr uint32_t data = 1024;
360     EXPECT_FALSE(IsTemplateArraysValid(nullptr));
361     Uint64Array array = {};
362     array.len = arrayLen;
363     array.data = nullptr;
364     EXPECT_FALSE(IsTemplateArraysValid(&array));
365     array.len = 1;
366     EXPECT_FALSE(IsTemplateArraysValid(&array));
367     uint64_t temp = data;
368     array.data = &temp;
369     EXPECT_TRUE(IsTemplateArraysValid(&array));
370     array.len = 0;
371     EXPECT_TRUE(IsTemplateArraysValid(&array));
372 }
373 
HWTEST_F(CoAuthTest, TestCopyTemplateArrays, TestSize.Level0)374 HWTEST_F(CoAuthTest, TestCopyTemplateArrays, TestSize.Level0)
375 {
376     constexpr uint32_t arrayLen = 1;
377     constexpr uint32_t data = 1024;
378     EXPECT_EQ(CopyTemplateArrays(nullptr, nullptr), RESULT_BAD_PARAM);
379     Uint64Array inArray = {};
380     inArray.len = arrayLen;
381     uint64_t temp = data;
382     inArray.data = &temp;
383     EXPECT_EQ(CopyTemplateArrays(&inArray, nullptr), RESULT_BAD_PARAM);
384     Uint64Array outArray = {};
385     uint64_t num = 0;
386     outArray.data = &num;
387     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_BAD_PARAM);
388     outArray.data = nullptr;
389     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_SUCCESS);
390     inArray.len = 0;
391     outArray.data = nullptr;
392     EXPECT_EQ(CopyTemplateArrays(&inArray, &outArray), RESULT_SUCCESS);
393 }
394 } // namespace UserAuth
395 } // namespace UserIam
396 } // namespace OHOS
397