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