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