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
31using namespace testing::ext;
32class DevSLMgrTest : public testing::Test {
33public:
34    DevSLMgrTest();
35    ~DevSLMgrTest();
36    static void SetUpTestCase();
37    static void TearDownTestCase();
38    void SetUp() override;
39    void TearDown() override;
40private:
41    static bool isEnforcing_;
42};
43
44static const int32_t DEV_SEC_LEVEL_ERR = 100;
45static const int32_t LIST_LENGTH = 128;
46
47struct DeviceSecurityInfo {
48    uint32_t magicNum {0};
49    uint32_t result {0};
50    uint32_t level {0};
51};
52
53extern "C" {
54    extern void OnApiDeviceSecInfoCallback(const DeviceIdentify *identify, struct DeviceSecurityInfo *info);
55}
56
57static 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
79DevSLMgrTest::DevSLMgrTest() {}
80DevSLMgrTest::~DevSLMgrTest() {}
81void 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}
91void DevSLMgrTest::TearDownTestCase()
92{
93    if (DevSLMgrTest::isEnforcing_) {
94        OHOS::SaveStringToFile("/sys/fs/selinux/enforce", "1");
95    }
96}
97void DevSLMgrTest::SetUp() {}
98
99void DevSLMgrTest::TearDown() {}
100
101bool DevSLMgrTest::isEnforcing_ = false;
102
103static 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
110static 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
117static 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
124static 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
135static 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
144static 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
156static 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
171static 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
188static 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
205static void tmpCallback000(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
206{
207    EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
208}
209
210static 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
221static 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
235static 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
241static 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
255static int32_t g_cnt = 0;
256static std::mutex g_mtx;
257static std::condition_variable g_cv;
258
259static void tmpCallbackLocal(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
260{
261    g_cnt++;
262    EXPECT_EQ(DEVSL_SUCCESS, result);
263}
264
265static 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);
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
285static 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
317static 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
363static struct DATASLListParams *g_tmpList = nullptr;
364
365static void ListCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
366{
367    EXPECT_EQ(result, DEVSL_SUCCESS);
368}
369
370static 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
405static void tmpCallbackExcept004(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
406{
407    EXPECT_EQ(DEVSL_ERR_BAD_PARAMETERS, result);
408}
409
410static 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
426static 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
454static 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}