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 "softbus_bus_center.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 const char *pkgName = "ohos.dslm";
127 NodeBasicInfo info;
128 int32_t ret = GetLocalNodeDeviceInfo(pkgName, &info);
129 if (GetNodeKeyInfo(pkgName, info.networkId, NODE_KEY_UDID, (uint8_t *)(queryParams->udid), UDID_BUF_LEN) != 0) {
130 return ret;
131 }
132 queryParams->udidLen = MAX_UDID_LENGTH;
133 return DEVSL_SUCCESS;
134 }
135
136 static HWTEST_F(DevSLMgrTest, TestOnstart, TestSize.Level1)
137 {
138 int32_t ret;
139
140 ret = DATASL_OnStart();
141 EXPECT_EQ(DEVSL_SUCCESS, ret);
142 DATASL_OnStop();
143 }
144
145 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel001, TestSize.Level1)
146 {
147 int32_t ret;
148 uint32_t levelInfo = 0;
149
150 ret = DATASL_OnStart();
151 EXPECT_EQ(DEVSL_SUCCESS, ret);
152 ret = DATASL_GetHighestSecLevel(nullptr, &levelInfo);
153 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
154 DATASL_OnStop();
155 }
156
157 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel002, TestSize.Level1)
158 {
159 int32_t ret;
160
161 DEVSLQueryParams queryParams;
162 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
163 DATASL_GetUdidByOpp(&queryParams);
164
165 ret = DATASL_OnStart();
166 EXPECT_EQ(DEVSL_SUCCESS, ret);
167 ret = DATASL_GetHighestSecLevel(&queryParams, nullptr);
168 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
169 DATASL_OnStop();
170 }
171
172 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel003, TestSize.Level1)
173 {
174 int32_t ret;
175 uint32_t levelInfo = 0;
176
177 DEVSLQueryParams queryParams;
178 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
179 DATASL_GetUdidByOpp(&queryParams);
180
181 ret = DATASL_OnStart();
182 EXPECT_EQ(DEVSL_SUCCESS, ret);
183 ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
184 EXPECT_EQ(DATA_SEC_LEVEL0, static_cast<int32_t>(levelInfo));
185 EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
186 DATASL_OnStop();
187 }
188
189 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevel004, TestSize.Level1)
190 {
191 int32_t ret;
192 uint32_t levelInfo = 0;
193
194 DEVSLQueryParams queryParams;
195 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
196 ret = GetLocalUdid(&queryParams);
197 EXPECT_EQ(DEVSL_SUCCESS, ret);
198
199 ret = DATASL_OnStart();
200 EXPECT_EQ(DEVSL_SUCCESS, ret);
201 ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
202 EXPECT_EQ(DEVSL_SUCCESS, ret);
203 DATASL_OnStop();
204 }
205
tmpCallback000(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)206 static void tmpCallback000(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
207 {
208 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
209 }
210
211 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync001, TestSize.Level1)
212 {
213 int32_t ret;
214
215 ret = DATASL_OnStart();
216 EXPECT_EQ(DEVSL_SUCCESS, ret);
217 ret = DATASL_GetHighestSecLevelAsync(nullptr, &tmpCallback000);
218 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
219 DATASL_OnStop();
220 }
221
222 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync002, TestSize.Level1)
223 {
224 int32_t ret;
225 DEVSLQueryParams queryParams;
226 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
227 DATASL_GetUdidByOpp(&queryParams);
228
229 ret = DATASL_OnStart();
230 EXPECT_EQ(DEVSL_SUCCESS, ret);
231 ret = DATASL_GetHighestSecLevelAsync(&queryParams, nullptr);
232 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
233 DATASL_OnStop();
234 }
235
tmpCallback(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)236 static void tmpCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
237 {
238 EXPECT_EQ(ERR_NOEXIST_DEVICE, result);
239 EXPECT_EQ(DATA_SEC_LEVEL0, static_cast<int32_t>(levelInfo));
240 }
241
242 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync003, TestSize.Level1)
243 {
244 int32_t ret;
245 DEVSLQueryParams queryParams;
246 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
247 DATASL_GetUdidByOpp(&queryParams);
248
249 ret = DATASL_OnStart();
250 EXPECT_EQ(DEVSL_SUCCESS, ret);
251 ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallback);
252 EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
253 DATASL_OnStop();
254 }
255
256 static int32_t g_cnt = 0;
257 static std::mutex g_mtx;
258 static std::condition_variable g_cv;
259
tmpCallbackLocal(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)260 static void tmpCallbackLocal(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
261 {
262 g_cnt++;
263 EXPECT_EQ(DEVSL_SUCCESS, result);
264 }
265
266 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelAsync004, TestSize.Level1)
267 {
268 int32_t ret;
269 DEVSLQueryParams queryParams;
270 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
271 ret = GetLocalUdid(&queryParams);
272 EXPECT_EQ(DEVSL_SUCCESS, ret);
273
274 ret = DATASL_OnStart();
275 EXPECT_EQ(DEVSL_SUCCESS, ret);
276 ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallbackLocal);
277 EXPECT_EQ(DEVSL_SUCCESS, ret);
278
279 std::unique_lock<std::mutex> lck(g_mtx);
__anon9e7ebfa40102() 280 g_cv.wait_for(lck, std::chrono::milliseconds(2000), []() { return (g_cnt == 1); });
281 EXPECT_EQ(g_cnt, 1);
282
283 DATASL_OnStop();
284 }
285
286 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept001, TestSize.Level1)
287 {
288 OnApiDeviceSecInfoCallback(nullptr, nullptr);
289 GetDeviceSecLevelByUdidAsync(nullptr, 0);
290 int32_t ret;
291 uint32_t levelInfo = 0;
292 int32_t devLevel = 0;
293 DEVSLQueryParams queryParams;
294 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
295 DATASL_GetUdidByExcept(&queryParams);
296 ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParams.udid), queryParams.udidLen, &devLevel);
297 EXPECT_EQ(DEVSL_ERROR, ret);
298 ret = DATASL_OnStart();
299 EXPECT_EQ(DEVSL_SUCCESS, ret);
300 ret = StartDevslEnv();
301 EXPECT_EQ(DEVSL_SUCCESS, ret);
302
303 ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
304 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
305
306 DeviceIdentify devId;
307 (void)memset_s(&devId, sizeof(devId), 0, sizeof(devId));
308 (void)memcpy_s(devId.identity, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
309 devId.length = queryParams.udidLen;
310 DeviceSecurityInfo devInfo;
311
312 OnApiDeviceSecInfoCallback(&devId, nullptr);
313 OnApiDeviceSecInfoCallback(&devId, &devInfo);
314
315 DATASL_OnStop();
316 }
317
318 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept002, TestSize.Level1)
319 {
320 int32_t ret;
321 int32_t devLevel = 0;
322 ret = DATASL_OnStart();
323 EXPECT_EQ(DEVSL_SUCCESS, ret);
324
325 DEVSLQueryParams queryParamsLocal;
326 (void)memset_s(&queryParamsLocal, sizeof(queryParamsLocal), 0, sizeof(queryParamsLocal));
327 ret = GetLocalUdid(&queryParamsLocal);
328 EXPECT_EQ(DEVSL_SUCCESS, ret);
329
330 DeviceSecurityInfo devInfo;
331 DeviceIdentify devIdLocal;
332 (void)memset_s(&devIdLocal, sizeof(devIdLocal), 0, sizeof(devIdLocal));
333 (void)memcpy_s(devIdLocal.identity, MAX_UDID_LENGTH, queryParamsLocal.udid, queryParamsLocal.udidLen);
334 devIdLocal.length = queryParamsLocal.udidLen;
335 OnApiDeviceSecInfoCallback(&devIdLocal, &devInfo);
336
337 DEVSLQueryParams queryParams;
338 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
339 DATASL_GetUdidByExcept(&queryParams);
340 DEVSLQueryParams queryParamsOpp;
341 (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
342 DATASL_GetUdidByOpp(&queryParamsOpp);
343 ret = GetDeviceSecLevelByUdid(static_cast<const uint8_t *>(queryParamsOpp.udid), queryParamsOpp.udidLen, &devLevel);
344 EXPECT_EQ(ERR_NOEXIST_DEVICE, ret);
345
346 DeviceIdentify devIdOpp;
347 OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
348
349 ret = CompareUdid(&queryParamsLocal, &queryParams);
350 EXPECT_EQ(DEVSL_ERROR, ret);
351
352 ret = CompareUdid(&queryParamsLocal, &queryParamsOpp);
353 EXPECT_EQ(DEVSL_ERROR, ret);
354
355 ret = CompareUdid(&queryParamsLocal, &queryParamsLocal);
356
357 uint32_t result = GetDataSecLevelByDevSecLevel(DEV_SEC_LEVEL_ERR);
358 EXPECT_EQ(DATA_SEC_LEVEL0, result);
359
360 EXPECT_EQ(DEVSL_SUCCESS, ret);
361 DATASL_OnStop();
362 }
363
364 static struct DATASLListParams *g_tmpList = nullptr;
365
ListCallback(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)366 static void ListCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
367 {
368 EXPECT_EQ(result, DEVSL_SUCCESS);
369 }
370
371 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept003, TestSize.Level1)
372 {
373 int32_t ret = InitPthreadMutex();
374 EXPECT_EQ(DEVSL_SUCCESS, ret);
375
376 ClearList(g_tmpList);
377 DEVSLQueryParams queryParamsOpp;
378 (void)memset_s(&queryParamsOpp, sizeof(queryParamsOpp), 0, sizeof(queryParamsOpp));
379 DATASL_GetUdidByOpp(&queryParamsOpp);
380
381 DeviceIdentify devIdOpp;
382 (void)memset_s(&devIdOpp, sizeof(devIdOpp), 0, sizeof(devIdOpp));
383 (void)memcpy_s(devIdOpp.identity, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
384 devIdOpp.length = queryParamsOpp.udidLen;
385 DeviceSecurityInfo devInfo;
386
387 OnApiDeviceSecInfoCallback(&devIdOpp, &devInfo);
388
389 g_tmpList = InitList();
390 EXPECT_NE(g_tmpList, nullptr);
391
392 struct DATASLCallbackParams *newListNode =
393 (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
394 EXPECT_NE(newListNode, nullptr);
395 (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParamsOpp.udid, queryParamsOpp.udidLen);
396 newListNode->queryParams.udidLen = queryParamsOpp.udidLen;
397 newListNode->callback = &ListCallback;
398
399 PushListNode(g_tmpList, newListNode);
400 RemoveListNode(g_tmpList, newListNode);
401 ClearList(g_tmpList);
402 g_tmpList = nullptr;
403 DestroyPthreadMutex();
404 }
405
tmpCallbackExcept004(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)406 static void tmpCallbackExcept004(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
407 {
408 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
409 }
410
AddList(void)411 static void AddList(void)
412 {
413 DEVSLQueryParams queryParams;
414 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
415 (void)GetLocalUdid(&queryParams);
416
417 struct DATASLCallbackParams *newListNode =
418 (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
419 EXPECT_NE(newListNode, nullptr);
420 (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
421 newListNode->queryParams.udidLen = queryParams.udidLen;
422 newListNode->callback = &tmpCallbackExcept004;
423
424 PushListNode(g_tmpList, newListNode);
425 }
426
427 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept004, TestSize.Level1)
428 {
429 int32_t ret;
430 ret = DATASL_OnStart();
431 EXPECT_EQ(DEVSL_SUCCESS, ret);
432
433 DEVSLQueryParams queryParams;
434 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
435 DATASL_GetUdidByExceptZero(&queryParams);
436 uint32_t levelInfo = 0;
437 ret = DATASL_GetHighestSecLevel(&queryParams, &levelInfo);
438 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
439
440 ret = DATASL_GetHighestSecLevelAsync(&queryParams, &tmpCallbackExcept004);
441 EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, ret);
442
443 g_tmpList = InitList();
444 EXPECT_NE(g_tmpList, nullptr);
445 for (int i = 0; i < LIST_LENGTH; i++) {
446 AddList();
447 }
448 (void)GetListLength(g_tmpList);
449
450 ClearList(g_tmpList);
451 g_tmpList = nullptr;
452 DATASL_OnStop();
453 }
454
455 static HWTEST_F(DevSLMgrTest, TestGetHighestSecLevelExcept005, TestSize.Level1)
456 {
457 int32_t ret;
458 ret = DATASL_OnStart();
459 EXPECT_EQ(DEVSL_SUCCESS, ret);
460
461 g_tmpList = InitList();
462 EXPECT_NE(g_tmpList, nullptr);
463
464 DEVSLQueryParams queryParams;
465 (void)memset_s(&queryParams, sizeof(queryParams), 0, sizeof(queryParams));
466 (void)GetLocalUdid(&queryParams);
467 struct DATASLCallbackParams *newListNode =
468 (struct DATASLCallbackParams*)malloc(sizeof(struct DATASLCallbackParams));
469 EXPECT_NE(newListNode, nullptr);
470 (void)memcpy_s(newListNode->queryParams.udid, MAX_UDID_LENGTH, queryParams.udid, queryParams.udidLen);
471 newListNode->queryParams.udidLen = queryParams.udidLen;
472 newListNode->callback = nullptr;
473 RemoveListNode(g_tmpList, newListNode);
474 PushListNode(g_tmpList, newListNode);
475 RemoveListNode(g_tmpList, newListNode);
476
477 ClearList(g_tmpList);
478 g_tmpList = nullptr;
479 DATASL_OnStop();
480 }