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 <iostream>
17 #include <mutex>
18 #include <thread>
19 #include <condition_variable>
20 #include "gtest/gtest.h"
21 #include "file_ex.h"
22 #include "securec.h"
23 #include "parameter.h"
24 #include "dev_slinfo_adpt.h"
25 #include "DevSLMgrTest.h"
26 #include "DevslinfoListTest.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29 #include "accesstoken_kit.h"
30 
31 using namespace testing::ext;
32 class DevSLMgrTest : public testing::Test {
33 public:
34     DevSLMgrTest();
35     ~DevSLMgrTest();
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp() override;
39     void TearDown() override;
40 private:
41     static bool isEnforcing_;
42 };
43 
44 static const int32_t DEV_SEC_LEVEL_ERR = 100;
45 static const int32_t LIST_LENGTH = 128;
46 
47 struct DeviceSecurityInfo {
48     uint32_t magicNum {0};
49     uint32_t result {0};
50     uint32_t level {0};
51 };
52 
53 extern "C" {
54     extern void OnApiDeviceSecInfoCallback(const DeviceIdentify *identify, struct DeviceSecurityInfo *info);
55 }
56 
NativeTokenGet()57 static void NativeTokenGet()
58 {
59     uint64_t tokenId;
60     const char **perms = new const char *[1];
61     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
62     NativeTokenInfoParams infoInstance = {
63         .dcapsNum = 0,
64         .permsNum = 1,
65         .aclsNum = 0,
66         .dcaps = nullptr,
67         .perms = perms,
68         .acls = nullptr,
69         .aplStr = "system_basic",
70     };
71 
72     infoInstance.processName = "DevSLMgrTest";
73     tokenId = GetAccessTokenId(&infoInstance);
74     SetSelfTokenID(tokenId);
75     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
76     delete[] perms;
77 }
78 
DevSLMgrTest()79 DevSLMgrTest::DevSLMgrTest() {}
~DevSLMgrTest()80 DevSLMgrTest::~DevSLMgrTest() {}
SetUpTestCase()81 void DevSLMgrTest::SetUpTestCase()
82 {
83     string isEnforcing;
84     OHOS::LoadStringFromFile("/sys/fs/selinux/enforce", isEnforcing);
85     if (isEnforcing.compare("1") == 0) {
86         DevSLMgrTest::isEnforcing_ = true;
87         OHOS::SaveStringToFile("/sys/fs/selinux/enforce", "0");
88     }
89     NativeTokenGet();
90 }
TearDownTestCase()91 void DevSLMgrTest::TearDownTestCase()
92 {
93     if (DevSLMgrTest::isEnforcing_) {
94         OHOS::SaveStringToFile("/sys/fs/selinux/enforce", "1");
95     }
96 }
SetUp()97 void DevSLMgrTest::SetUp() {}
98 
TearDown()99 void DevSLMgrTest::TearDown() {}
100 
101 bool DevSLMgrTest::isEnforcing_ = false;
102 
DATASL_GetUdidByOpp(DEVSLQueryParams * queryParams)103 static void DATASL_GetUdidByOpp(DEVSLQueryParams *queryParams)
104 {
105     char udid[65] = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
106     (void)memcpy_s(queryParams->udid, MAX_UDID_LENGTH, udid, MAX_UDID_LENGTH);
107     queryParams->udidLen = MAX_UDID_LENGTH;
108 }
109 
DATASL_GetUdidByExcept(DEVSLQueryParams * queryParams)110 static void DATASL_GetUdidByExcept(DEVSLQueryParams *queryParams)
111 {
112     char udid[65] = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
113     (void)memcpy_s(queryParams->udid, MAX_UDID_LENGTH, udid, MAX_UDID_LENGTH);
114     queryParams->udidLen = MAX_UDID_LENGTH + 1;
115 }
116 
DATASL_GetUdidByExceptZero(DEVSLQueryParams * queryParams)117 static void DATASL_GetUdidByExceptZero(DEVSLQueryParams *queryParams)
118 {
119     char udid[65] = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
120     (void)memcpy_s(queryParams->udid, MAX_UDID_LENGTH, udid, MAX_UDID_LENGTH);
121     queryParams->udidLen = 0;
122 }
123 
GetLocalUdid(DEVSLQueryParams * queryParams)124 static int32_t GetLocalUdid(DEVSLQueryParams *queryParams)
125 {
126     char udid[65] = {0};
127     int32_t ret = GetDevUdid(udid, MAX_UDID_LENGTH + 1);
128     EXPECT_EQ(DEVSL_SUCCESS, ret);
129 
130     (void)memcpy_s(queryParams->udid, MAX_UDID_LENGTH, udid, MAX_UDID_LENGTH);
131     queryParams->udidLen = MAX_UDID_LENGTH;
132     return ret;
133 }
134 
135 static HWTEST_F(DevSLMgrTest, TestOnstart, TestSize.Level1)
136 {
137     int32_t ret;
138 
139     ret = DATASL_OnStart();
140     EXPECT_EQ(DEVSL_SUCCESS, ret);
141     DATASL_OnStop();
142 }
143 
144 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel001, TestSize.Level1)
145 {
146     int32_t ret;
147     uint32_t levelInfo = 0;
148 
149     ret = DATASL_OnStart();
150     EXPECT_EQ(DEVSL_SUCCESS, ret);
151     ret = DATASL_GetHighestSecLevel(nullptr, &levelInfo);
152     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
153     DATASL_OnStop();
154 }
155 
156 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel002, TestSize.Level1)
157 {
158     int32_t ret;
159 
160     DEVSLQueryParams queryParams;
161     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
162     DATASL_GetUdidByOpp(&queryParams);
163 
164     ret = DATASL_OnStart();
165     EXPECT_EQ(DEVSL_SUCCESS, ret);
166     ret = DATASL_GetHighestSecLevel(&queryParams, nullptr);
167     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
168     DATASL_OnStop();
169 }
170 
171 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel003, TestSize.Level1)
172 {
173     int32_t ret;
174     uint32_t levelInfo = 0;
175 
176     DEVSLQueryParams queryParams;
177     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
178     DATASL_GetUdidByOpp(&queryParams);
179 
180     ret = DATASL_OnStart();
181     EXPECT_EQ(DEVSL_SUCCESS, ret);
182     ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
183     EXPECT_EQ(DATA_SEC_LEVEL0, static_cast<int32_t>(levelInfo));
184     EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
185     DATASL_OnStop();
186 }
187 
188 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel004, TestSize.Level1)
189 {
190     int32_t ret;
191     uint32_t levelInfo = 0;
192 
193     DEVSLQueryParams queryParams;
194     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
195     ret = GetLocalUdid(&queryParams);
196     EXPECT_EQ(DEVSL_SUCCESS, ret);
197 
198     ret = DATASL_OnStart();
199     EXPECT_EQ(DEVSL_SUCCESS, ret);
200     ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
201     EXPECT_EQ(DEVSL_SUCCESS, ret);
202     DATASL_OnStop();
203 }
204 
tmpCallback000(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)205 static void tmpCallback000(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
206 {
207     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
208 }
209 
210 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync001, TestSize.Level1)
211 {
212     int32_t ret;
213 
214     ret = DATASL_OnStart();
215     EXPECT_EQ(DEVSL_SUCCESS, ret);
216     ret = DATASL_GetHighestSecLevelAsync(nullptr, &tmpCallback000);
217     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
218     DATASL_OnStop();
219 }
220 
221 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync002, TestSize.Level1)
222 {
223     int32_t ret;
224     DEVSLQueryParams queryParams;
225     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
226     DATASL_GetUdidByOpp(&queryParams);
227 
228     ret = DATASL_OnStart();
229     EXPECT_EQ(DEVSL_SUCCESS, ret);
230     ret = DATASL_GetHighestSecLevelAsync(&queryParams, nullptr);
231     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
232     DATASL_OnStop();
233 }
234 
tmpCallback(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)235 static void tmpCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
236 {
237     EXPECT_EQ(ERR_NOEXIST_DEVICE, result);
238     EXPECT_EQ(DATA_SEC_LEVEL0, static_cast<int32_t>(levelInfo));
239 }
240 
241 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync003, TestSize.Level1)
242 {
243     int32_t ret;
244     DEVSLQueryParams queryParams;
245     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
246     DATASL_GetUdidByOpp(&queryParams);
247 
248     ret = DATASL_OnStart();
249     EXPECT_EQ(DEVSL_SUCCESS, ret);
250     ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallback);
251     EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
252     DATASL_OnStop();
253 }
254 
255 static int32_t g_cnt = 0;
256 static std::mutex g_mtx;
257 static std::condition_variable g_cv;
258 
tmpCallbackLocal(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)259 static void tmpCallbackLocal(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
260 {
261     g_cnt++;
262     EXPECT_EQ(DEVSL_SUCCESS, result);
263 }
264 
265 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync004, TestSize.Level1)
266 {
267     int32_t ret;
268     DEVSLQueryParams queryParams;
269     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
270     ret = GetLocalUdid(&queryParams);
271     EXPECT_EQ(DEVSL_SUCCESS, ret);
272 
273     ret = DATASL_OnStart();
274     EXPECT_EQ(DEVSL_SUCCESS, ret);
275     ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallbackLocal);
276     EXPECT_EQ(DEVSL_SUCCESS, ret);
277 
278     std::unique_lock<std::mutex> lck(g_mtx);
__anonfac2877b0102() 279     g_cv.wait_for(lck, std::chrono::milliseconds(2000), []() { return (g_cnt == 1); });
280     EXPECT_EQ(g_cnt, 1);
281 
282     DATASL_OnStop();
283 }
284 
285 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept001, TestSize.Level1)
286 {
287     OnApiDeviceSecInfoCallback(nullptr, nullptr);
288     GetDeviceSecLevelByUdidAsync(nullptr, 0);
289     int32_t ret;
290     uint32_t levelInfo = 0;
291     int32_t devLevel = 0;
292     DEVSLQueryParams queryParams;
293     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
294     DATASL_GetUdidByExcept(&queryParams);
295     ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParams.udid), queryParams.udidLen, &devLevel);
296     EXPECT_EQ(DEVSL_ERROR, ret);
297     ret = DATASL_OnStart();
298     EXPECT_EQ(DEVSL_SUCCESS, ret);
299     ret = StartDevslEnv();
300     EXPECT_EQ(DEVSL_SUCCESS, ret);
301 
302     ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
303     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
304 
305     DeviceIdentify devId;
306     (void)memset_s(&devId, sizeof(devId), 0, sizeof(devId));
307     (void)memcpy_s(devId.identity, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
308     devId.length = queryParams.udidLen;
309     DeviceSecurityInfo devInfo;
310 
311     OnApiDeviceSecInfoCallback(&devId, nullptr);
312     OnApiDeviceSecInfoCallback(&devId, &devInfo);
313 
314     DATASL_OnStop();
315 }
316 
317 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept002, TestSize.Level1)
318 {
319     int32_t ret;
320     int32_t devLevel = 0;
321     ret = DATASL_OnStart();
322     EXPECT_EQ(DEVSL_SUCCESS, ret);
323 
324     DEVSLQueryParams queryParamsLocal;
325     (void)memset_s(&queryParamsLocal, sizeof(queryParamsLocal), 0, sizeof(queryParamsLocal));
326     ret = GetLocalUdid(&queryParamsLocal);
327     EXPECT_EQ(DEVSL_SUCCESS, ret);
328 
329     DeviceSecurityInfo devInfo;
330     DeviceIdentify devIdLocal;
331     (void)memset_s(&devIdLocal, sizeof(devIdLocal), 0, sizeof(devIdLocal));
332     (void)memcpy_s(devIdLocal.identity, MAX_UDID_LENGTH, queryParamsLocal.udid, queryParamsLocal.udidLen);
333     devIdLocal.length = queryParamsLocal.udidLen;
334     OnApiDeviceSecInfoCallback(&devIdLocal, &devInfo);
335 
336     DEVSLQueryParams queryParams;
337     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
338     DATASL_GetUdidByExcept(&queryParams);
339     DEVSLQueryParams queryParamsOpp;
340     (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
341     DATASL_GetUdidByOpp(&queryParamsOpp);
342     ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParamsOpp.udid), queryParamsOpp.udidLen, &devLevel);
343     EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
344 
345     DeviceIdentify devIdOpp;
346     OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
347 
348     ret = CompareUdid(&queryParamsLocal, &queryParams);
349     EXPECT_EQ(DEVSL_ERROR, ret);
350 
351     ret = CompareUdid(&queryParamsLocal, &queryParamsOpp);
352     EXPECT_EQ(DEVSL_ERROR, ret);
353 
354     ret = CompareUdid(&queryParamsLocal, &queryParamsLocal);
355 
356     uint32_t result = GetDataSecLevelByDevSecLevel(DEV_SEC_LEVEL_ERR);
357     EXPECT_EQ(DATA_SEC_LEVEL0, result);
358 
359     EXPECT_EQ(DEVSL_SUCCESS, ret);
360     DATASL_OnStop();
361 }
362 
363 static struct DATASLListParams *g_tmpList = nullptr;
364 
ListCallback(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)365 static void ListCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
366 {
367     EXPECT_EQ(result, DEVSL_SUCCESS);
368 }
369 
370 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept003, TestSize.Level1)
371 {
372     int32_t ret = InitPthreadMutex();
373     EXPECT_EQ(DEVSL_SUCCESS, ret);
374 
375     ClearList(g_tmpList);
376     DEVSLQueryParams queryParamsOpp;
377     (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
378     DATASL_GetUdidByOpp(&queryParamsOpp);
379 
380     DeviceIdentify devIdOpp;
381     (void)memset_s(&devIdOpp, sizeof(devIdOpp), 0, sizeof(devIdOpp));
382     (void)memcpy_s(devIdOpp.identity, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
383     devIdOpp.length = queryParamsOpp.udidLen;
384     DeviceSecurityInfo devInfo;
385 
386     OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
387 
388     g_tmpList = InitList();
389     EXPECT_NE(g_tmpList, nullptr);
390 
391     struct DATASLCallbackParams *newListNode =
392         (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
393     EXPECT_NE(newListNode, nullptr);
394     (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
395     newListNode->queryParams.udidLen = queryParamsOpp.udidLen;
396     newListNode->callback = &ListCallback;
397 
398     PushListNode(g_tmpList, newListNode);
399     RemoveListNode(g_tmpList, newListNode);
400     ClearList(g_tmpList);
401     g_tmpList = nullptr;
402     DestroyPthreadMutex();
403 }
404 
tmpCallbackExcept004(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)405 static void tmpCallbackExcept004(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
406 {
407     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
408 }
409 
AddList(void)410 static void AddList(void)
411 {
412     DEVSLQueryParams queryParams;
413     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
414     (void)GetLocalUdid(&queryParams);
415 
416     struct DATASLCallbackParams *newListNode =
417         (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
418     EXPECT_NE(newListNode, nullptr);
419     (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
420     newListNode->queryParams.udidLen = queryParams.udidLen;
421     newListNode->callback = &tmpCallbackExcept004;
422 
423     PushListNode(g_tmpList, newListNode);
424 }
425 
426 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept004, TestSize.Level1)
427 {
428     int32_t ret;
429     ret = DATASL_OnStart();
430     EXPECT_EQ(DEVSL_SUCCESS, ret);
431 
432     DEVSLQueryParams queryParams;
433     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
434     DATASL_GetUdidByExceptZero(&queryParams);
435     uint32_t levelInfo = 0;
436     ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
437     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
438 
439     ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallbackExcept004);
440     EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
441 
442     g_tmpList = InitList();
443     EXPECT_NE(g_tmpList, nullptr);
444     for (int i = 0; i < LIST_LENGTH; i++) {
445         AddList();
446     }
447     (void)GetListLength(g_tmpList);
448 
449     ClearList(g_tmpList);
450     g_tmpList = nullptr;
451     DATASL_OnStop();
452 }
453 
454 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept005, TestSize.Level1)
455 {
456     int32_t ret;
457     ret = DATASL_OnStart();
458     EXPECT_EQ(DEVSL_SUCCESS, ret);
459 
460     g_tmpList = InitList();
461     EXPECT_NE(g_tmpList, nullptr);
462 
463     DEVSLQueryParams queryParams;
464     (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
465     (void)GetLocalUdid(&queryParams);
466     struct DATASLCallbackParams *newListNode =
467         (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
468     EXPECT_NE(newListNode, nullptr);
469     (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
470     newListNode->queryParams.udidLen = queryParams.udidLen;
471     newListNode->callback = nullptr;
472     RemoveListNode(g_tmpList, newListNode);
473     PushListNode(g_tmpList, newListNode);
474     RemoveListNode(g_tmpList, newListNode);
475 
476     ClearList(g_tmpList);
477     g_tmpList = nullptr;
478     DATASL_OnStop();
479 }