1 /*
2  * Copyright (c) 2023-2024 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 "dlp_permission_service_test.h"
17 #include <openssl/rand.h>
18 #include <string>
19 #include "accesstoken_kit.h"
20 #include "account_adapt.h"
21 #include "app_uninstall_observer.h"
22 #include "cert_parcel.h"
23 #define private public
24 #include "dlp_sandbox_change_callback_manager.h"
25 #include "open_dlp_file_callback_manager.h"
26 #undef private
27 #include "dlp_permission.h"
28 #include "dlp_permission_async_stub.h"
29 #include "dlp_permission_kit.h"
30 #include "dlp_permission_log.h"
31 #include "dlp_permission_serializer.h"
32 #include "dlp_sandbox_change_callback_proxy.h"
33 #include "dlp_sandbox_change_callback_stub.h"
34 #include "dlp_sandbox_change_callback_death_recipient.h"
35 #include "file_operator.h"
36 #include "ipc_skeleton.h"
37 #include "open_dlp_file_callback_proxy.h"
38 #include "open_dlp_file_callback_stub.h"
39 #include "open_dlp_file_callback_death_recipient.h"
40 #include "permission_policy.h"
41 #include "retention_file_manager.h"
42 #include "sandbox_json_manager.h"
43 #include "visited_dlp_file_info.h"
44 #define private public
45 #include "visit_record_file_manager.h"
46 #include "visit_record_json_manager.h"
47 #undef private
48 
49 using namespace testing::ext;
50 using namespace OHOS;
51 using namespace OHOS::Security::DlpPermission;
52 using namespace OHOS::Security::AccessToken;
53 using namespace std::chrono;
54 
55 namespace {
56 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
57     LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpPermissionServiceTest"};
58 const std::string TEST_URI = "/data/service/el1/public/dlp_permission_service1/retention_sandbox_info_test.json";
59 static const int32_t DEFAULT_USERID = 100;
60 static const std::string DLP_MANAGER_APP = "com.ohos.dlpmanager";
61 static const std::string PERMISSION_APP = "com.ohos.permissionmanager";
62 const uint32_t ACCOUNT_LENGTH = 20;
63 const uint32_t USER_NUM = 1;
64 const int AUTH_PERM = 1;
65 const int64_t DELTA_EXPIRY_TIME = 200;
66 const uint64_t EXPIRY_TEN_MINUTE = 60 * 10;
67 const uint32_t AESKEY_LEN = 32;
68 const uint32_t HMACKEY_LEN = 32;
69 const std::string ENC_ACCOUNT_TYPE = "accountType";
70 const std::string ENC_DATA_LEN = "encDataLen";
71 const std::string ENC_DATA = "encData";
72 const std::string EXTRA_INFO_LEN = "extraInfoLen";
73 const std::string EXTRA_INFO = "extraInfo";
74 const std::string ENC_POLICY = "encPolicy";
75 static int32_t g_userId = 100;
76 static const uint8_t ARRAY_CHAR_SIZE = 62;
77 static const char CHAR_ARRAY[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
78 
79 static const std::string POLICY_CIPHER = "8B6696A5DD160005C9DCAF43025CB240958D1E53D8E54D70DBED8C191411FA60C9B5D491B"
80     "AE3F34F124DBA805736FCBBC175D881818A93A0E07C844E9DF9503641BF2A98EC49BE0BB2"
81     "E75397187D6A3DC9DEED05A341BFBB761C39C906A9E1344E2CB25432B9C190E1948334A3E"
82     "CDB49C4340A7A8977685E4FDB6EB9E329AB5EEB1EEEBAEF158B0442F98C342714553E50477"
83     "040A52AD79068E6BC68A2F0E2E500DA721927EFF985BDDAF7BCF78FA3BEF2730B25EC05458"
84     "0FDB5BB4EBE7294737E8BF53C6F69C93D00FF41581F80DEA67BB5EBD253BC43729CB8B560B"
85     "893154240AC355CDF8381C84A093B39E5CD6CFF5746FD068F8AA1DEDF2C3C2A12AE2A5CDE9"
86     "075C8AE86654AE4C696C7BE8EB4AB67E25008DE09A5218EFA13B59BAFDFB11FFBB6AD637B9"
87     "B02F598FE511910A9C9F614AF0EA8312F62DAA6C2DA9DCAF973321C45139669E2482C2CB09"
88     "4E60361ED2BA908A4C07443251DFD70762E2180FA5E92DA1CE6D9AAF70761382FC1591BF57"
89     "554693AC55F7121757AA3A4827C9016E1FF5A84FB367047EA7BB28B8E19521BA72AE0BB7C3"
90     "192F5B6D6887034C85A08659850DABD211CD18D5295DD60EEB98FB27C3161134D984665658"
91     "3E29E7C166EB1475647889B62448145D146A8A7A777B346AB7476A10209ED8543965EF3ED3"
92     "C3F96C1CBEDA994243E3064975C23F32F4412F42753668E2CC447E88D6D73534B9F8DD4221"
93     "1074D2D819CA235343D012283F30368DE7C3FBC3A90128EF8CFA86C80C5D7167A3CA60B1F5"
94     "93DDAD90BFF1987C9243ACD4463B11B61A87B9953A0CAE8FD93ACC1E0B0140410451E5CD3A"
95     "E6BB61CF5B1004F46782D924D79CE5615084102A19604BF99D38BFA8B837210022B6AB21E4"
96     "33B5D4E23E278C8CB5EC79DAFEF2A39E3175A0FC6921C37345CAF8D0976677924775A620C5"
97     "E63418C6339525433182D8D127816B36B348B781E02DA65ACCBEAE950CFF8579586B18B77A"
98     "9960ADF484881811D6044E3CC68577599194439E43263E4095CD5399679B548CDFD7430CFB"
99     "F67A1AE23B4136931E10032E4CEACC278584B45337CF7C3E4FEA6D0F1424E3CBC490E4C1DF"
100     "FC2927AA3BC5F57471EAA7D12C65064015A25A11D98E25AFCDB1A1DD876A03EADA9CDD015C"
101     "1265A7FDFA9A766BA832F4B9A2B55B73A361D2A7BD68572EB2ABE1B1DC93904CB5ACD09807"
102     "6FE5089AD8DB2F38DF7D0A76C2C87E36C6F6A5E8190EA76F1F8F0B2493F1FDF38B220BEBC5"
103     "554B3038FE83FD7D10C35034CB3D9409AC9F8F762149A4B19CD0B18B87F4251722EFEFB601"
104     "6DDFACBB8E6F9BAFD48FCFE5370B5661EC4218A65246337E1E24B14CE14EB82CE3B553B560"
105     "8A9A94B1E2E7BAC7CC0B315228E870DF25DFBB8F77A916B8B08692A92D9CB5540DCF4AA4CF"
106     "9B196026908";
107 
GetCurrentTimeSec(void)108 uint64_t GetCurrentTimeSec(void)
109 {
110     return static_cast<uint64_t>(duration_cast<seconds>(system_clock::now().time_since_epoch()).count());
111 }
112 
NewUserSample(AuthUserInfo & user)113 void NewUserSample(AuthUserInfo& user)
114 {
115     user.authAccount = "allowAccountA";
116     user.authPerm = FULL_CONTROL;
117     user.permExpiryTime = GetCurrentTimeSec() + EXPIRY_TEN_MINUTE;
118     user.authAccountType = OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT;
119 }
120 
GetRandNum()121 static uint8_t GetRandNum()
122 {
123     uint8_t rand;
124     RAND_bytes(reinterpret_cast<unsigned char *>(&rand), sizeof(rand));
125     return rand;
126 }
127 
GenerateRandArray(uint32_t len)128 uint8_t* GenerateRandArray(uint32_t len)
129 {
130     if (len < 1) {
131         DLP_LOG_ERROR(LABEL, "len error");
132         return nullptr;
133     }
134     uint8_t* str = new (std::nothrow) uint8_t[len];
135     if (str == nullptr) {
136         DLP_LOG_ERROR(LABEL, "New memory fail");
137         return nullptr;
138     }
139     for (uint32_t i = 0; i < len; i++) {
140         str[i] = GetRandNum() % 255; // uint8_t range 0 ~ 255
141     }
142     return str;
143 }
144 
GenerateRandStr(uint32_t len,std::string & res)145 static void GenerateRandStr(uint32_t len, std::string& res)
146 {
147     for (uint32_t i = 0; i < len; i++) {
148         uint32_t index = GetRandNum() % ARRAY_CHAR_SIZE;
149         DLP_LOG_INFO(LABEL, "%{public}u", index);
150         res.push_back(CHAR_ARRAY[index]);
151     }
152     DLP_LOG_INFO(LABEL, "%{public}s", res.c_str());
153 }
154 
155 struct GeneratePolicyParam {
156     uint32_t ownerAccountLen;
157     uint32_t aeskeyLen;
158     uint32_t ivLen;
159     uint32_t userNum;
160     uint32_t authAccountLen;
161     uint32_t authPerm;
162     int64_t deltaTime;
163     uint32_t hmacKeyLen;
164 };
165 
GeneratePolicy(PermissionPolicy & encPolicy,GeneratePolicyParam param)166 void GeneratePolicy(PermissionPolicy& encPolicy, GeneratePolicyParam param)
167 {
168     uint64_t curTime = static_cast<uint64_t>(
169         std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count());
170     GenerateRandStr(param.ownerAccountLen, encPolicy.ownerAccount_);
171     encPolicy.ownerAccountId_ = encPolicy.ownerAccount_;
172     encPolicy.ownerAccountType_ = OHOS::Security::DlpPermission::DlpAccountType::DOMAIN_ACCOUNT;
173     uint8_t* key = GenerateRandArray(param.aeskeyLen);
174     encPolicy.SetAeskey(key, param.aeskeyLen);
175     if (key != nullptr) {
176         delete[] key;
177         key = nullptr;
178     }
179     uint8_t* iv = GenerateRandArray(param.ivLen);
180     encPolicy.SetIv(iv, param.ivLen);
181     if (iv != nullptr) {
182         delete[] iv;
183         iv = nullptr;
184     }
185     uint8_t* hmacKey = GenerateRandArray(param.hmacKeyLen);
186     encPolicy.SetHmacKey(hmacKey, param.hmacKeyLen);
187     if (hmacKey != nullptr) {
188         delete[] hmacKey;
189         hmacKey = nullptr;
190     }
191 
192     for (uint32_t user = 0; user < param.userNum; ++user) {
193         std::string accountName;
194         GenerateRandStr(param.authAccountLen, accountName);
195         AuthUserInfo perminfo = {.authAccount = strdup(const_cast<char *>(accountName.c_str())),
196             .authPerm = static_cast<DLPFileAccess>(param.authPerm),
197             .permExpiryTime = curTime + param.deltaTime,
198             .authAccountType = OHOS::Security::DlpPermission::DlpAccountType::DOMAIN_ACCOUNT
199         };
200         encPolicy.authUsers_.emplace_back(perminfo);
201     }
202 }
203 }
204 
205 namespace OHOS {
206 namespace AccountSA {
GetOsAccountLocalIdFromUid(const int uid,int & id)207 ErrCode OsAccountManager::GetOsAccountLocalIdFromUid(const int uid, int &id)
208 {
209     id = DEFAULT_USERID;
210     return DLP_OK;
211 }
212 }
213 }
214 
SetUpTestCase()215 void DlpPermissionServiceTest::SetUpTestCase()
216 {}
217 
TearDownTestCase()218 void DlpPermissionServiceTest::TearDownTestCase()
219 {}
220 
SetUp()221 void DlpPermissionServiceTest::SetUp()
222 {
223     DLP_LOG_INFO(LABEL, "setup");
224     if (dlpPermissionService_ != nullptr) {
225         return;
226     }
227     dlpPermissionService_ = std::make_shared<DlpPermissionService>(SA_ID_DLP_PERMISSION_SERVICE, true);
228     ASSERT_NE(nullptr, dlpPermissionService_);
229     dlpPermissionService_->appStateObserver_ = new (std::nothrow) AppStateObserver();
230     ASSERT_TRUE(dlpPermissionService_->appStateObserver_ != nullptr);
231     GetUserIdByForegroundAccount(&g_userId);
232 }
233 
TearDown()234 void DlpPermissionServiceTest::TearDown()
235 {
236     if (dlpPermissionService_ != nullptr) {
237         dlpPermissionService_->appStateObserver_ = nullptr;
238     }
239     dlpPermissionService_ = nullptr;
240 }
241 
242 /**
243  * @tc.name: DumpTest001
244  * @tc.desc: dlp permission service dump test
245  * @tc.type: FUNC
246  * @tc.require:AR000HGIH9
247  */
248 HWTEST_F(DlpPermissionServiceTest, DumpTest001, TestSize.Level1)
249 {
250     DLP_LOG_INFO(LABEL, "DumpTest001");
251     int fd = -1;
252     std::vector<std::u16string> args;
253 
254     // fd is 0
255     EXPECT_EQ(ERR_INVALID_VALUE, dlpPermissionService_->Dump(fd, args));
256 
257     fd = 1;  // 1: std output
258 
259     // hidumper
260     EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
261 
262     // hidumper -h
263     args.emplace_back(Str8ToStr16("-h"));
264     EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
265 
266     args.clear();
267     // hidumper -d
268     args.emplace_back(Str8ToStr16("-d"));
269     EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
270 
271     args.clear();
272     // hidumper with not exist param
273     args.emplace_back(Str8ToStr16("-n"));
274     EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
275 
276     args.clear();
277 }
278 
279 class DlpSandboxChangeCallbackTest : public DlpSandboxChangeCallbackStub {
280 public:
281     DlpSandboxChangeCallbackTest() = default;
282     virtual ~DlpSandboxChangeCallbackTest() = default;
283 
284     void DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo& result) override;
285 };
286 
DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo & result)287 void DlpSandboxChangeCallbackTest::DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo& result) {}
288 
289 /**
290  * @tc.name:DlpSandboxChangeCallbackDeathRecipient001
291  * @tc.desc: DlpSandboxChangeCallbackDeathRecipient test
292  * @tc.type: FUNC
293  * @tc.require:DTS2023040302317
294  */
295 HWTEST_F(DlpPermissionServiceTest, DlpSandboxChangeCallbackDeathRecipient001, TestSize.Level1)
296 {
297     auto recipient = std::make_shared<DlpSandboxChangeCallbackDeathRecipient>();
298     ASSERT_NE(nullptr, recipient);
299 
300     recipient->OnRemoteDied(nullptr); // remote is nullptr
301 
302     // backup
303     sptr<IRemoteObject> callback;
304     wptr<IRemoteObject> remote = new (std::nothrow) DlpSandboxChangeCallbackTest();
305     callback = remote.promote();
306     dlpPermissionService_->RegisterDlpSandboxChangeCallback(callback);
307     ASSERT_EQ(static_cast<uint32_t>(1), DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.size());
308     recipient->OnRemoteDied(remote); // remote is not nullptr
309     ASSERT_EQ(static_cast<uint32_t>(0), DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.size());
310     bool result;
311     int32_t res = dlpPermissionService_->UnRegisterDlpSandboxChangeCallback(result);
312     ASSERT_EQ(DLP_CALLBACK_PARAM_INVALID, res);
313     recipient->OnRemoteDied(remote);
314 }
315 
316 class TestOpenDlpFileCallback : public OpenDlpFileCallbackStub {
317 public:
TestOpenDlpFileCallback()318     TestOpenDlpFileCallback() {}
~TestOpenDlpFileCallback()319     ~TestOpenDlpFileCallback() {}
320 
OnOpenDlpFile(OpenDlpFileCallbackInfo & result)321     void OnOpenDlpFile(OpenDlpFileCallbackInfo& result) override
322     {
323         called_ = true;
324     }
325     bool called_ = false;
326 };
327 
328 /**
329  * @tc.name: OpenDlpFileCallbackDeathRecipient001
330  * @tc.desc: OpenDlpFileCallbackDeathRecipient test
331  * @tc.type: FUNC
332  * @tc.require:
333  */
334 HWTEST_F(DlpPermissionServiceTest, OpenDlpFileCallbackDeathRecipient001, TestSize.Level1)
335 {
336     auto recipient = std::make_shared<OpenDlpFileCallbackDeathRecipient>();
337     ASSERT_NE(nullptr, recipient);
338 
339     recipient->OnRemoteDied(nullptr); // remote is nullptr
340 
341     // backup
342     OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
343     wptr<IRemoteObject> remote = new (std::nothrow) TestOpenDlpFileCallback();
344     sptr<IRemoteObject> callback = remote.promote();
345     int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
346         getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback);
347     EXPECT_EQ(DLP_OK, res);
348     EXPECT_EQ(static_cast<uint32_t>(1), OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.size());
349     recipient->OnRemoteDied(remote); // remote is not nullptr
350     EXPECT_EQ(static_cast<uint32_t>(0), OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.size());
351     res = dlpPermissionService_->UnRegisterOpenDlpFileCallback(callback);
352     EXPECT_EQ(DLP_CALLBACK_PARAM_INVALID, res);
353     recipient->OnRemoteDied(remote);
354 }
355 
356 /**
357  * @tc.name:FileOperator001
358  * @tc.desc: FileOperator test
359  * @tc.type: FUNC
360  * @tc.require:SR000I38N7
361  */
362 HWTEST_F(DlpPermissionServiceTest, FileOperator001, TestSize.Level1)
363 {
364     std::shared_ptr<FileOperator> fileOperator_ = std::make_shared<FileOperator>();
365     bool result = fileOperator_->IsExistFile("");
366     ASSERT_TRUE(!result);
367     std::string content = "test";
368     result = fileOperator_->IsExistDir("");
369     ASSERT_TRUE(!result);
370     int32_t res = fileOperator_->InputFileByPathAndContent(TEST_URI, content);
371     ASSERT_EQ(DLP_RETENTION_COMMON_FILE_OPEN_FAILED, res);
372     res = fileOperator_->GetFileContentByPath(TEST_URI, content);
373     ASSERT_EQ(DLP_RETENTION_FILE_FIND_FILE_ERROR, res);
374 };
375 
376 /**
377  * @tc.name:SandboxJsonManager001
378  * @tc.desc: SandboxJsonManager test
379  * @tc.type: FUNC
380  * @tc.require:SR000I38N7
381  */
382 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager001, TestSize.Level1)
383 {
384     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
385     RetentionInfo retentionInfo = {
386         .appIndex = 1,
387         .tokenId = 123456,
388         .bundleName = "test.bundlName",
389         .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
390         .userId = 100
391     };
392     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
393     int32_t res = sandboxJsonManager_->AddSandboxInfo(retentionInfo);
394     ASSERT_EQ(DLP_INSERT_FILE_ERROR, res);
395     std::set<std::string> docUriSet;
396     docUriSet.emplace("testUri");
397     RetentionInfo info;
398     info.bundleName = "";
399     info.tokenId = 0;
400     res = sandboxJsonManager_->UpdateRetentionState(docUriSet, info, false);
401     ASSERT_EQ(DLP_RETENTION_UPDATE_ERROR, res);
402 }
403 
404 /**
405  * @tc.name:CallbackManager001
406  * @tc.desc: DlpSandboxChangeCallbackManager test
407  * @tc.type: FUNC
408  * @tc.require:DTS2023040302317
409  */
410 HWTEST_F(DlpPermissionServiceTest, CallbackManager001, TestSize.Level1)
411 {
412     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().AddCallback(0, nullptr));
413     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(nullptr));
414     bool result;
415     ASSERT_EQ(
416         DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(0, result));
417     sptr<IRemoteObject> callback;
418     wptr<IRemoteObject> remote = new (std::nothrow) DlpSandboxChangeCallbackTest();
419     callback = remote.promote();
420     dlpPermissionService_->RegisterDlpSandboxChangeCallback(callback);
421     for (int i = 10000; i < 11024; i++) {
422         DlpSandboxChangeCallbackManager::GetInstance().AddCallback(i, callback);
423     }
424     ASSERT_EQ(
425         DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().AddCallback(11024, callback));
426     DlpSandboxInfo dlpSandboxInfo;
427     dlpSandboxInfo.pid = 1;
428     DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
429     dlpSandboxInfo.pid = 10010;
430     DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
431 }
432 
433 /**
434  * @tc.name:SandboxJsonManager002
435  * @tc.desc: SandboxJsonManager test
436  * @tc.type: FUNC
437  * @tc.require:DTS2023040302317
438  */
439 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager002, TestSize.Level1)
440 {
441     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
442     sandboxJsonManager_->FromJson(NULL);
443     RetentionInfo retentionInfo = {
444         .appIndex = 1,
445         .tokenId = 827878,
446         .bundleName = "testbundle",
447         .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
448         .userId = g_userId
449     };
450     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
451     ASSERT_TRUE(!sandboxJsonManager_->HasRetentionSandboxInfo("testbundle1"));
452     int32_t uid = getuid();
453     setuid(20010031);
454     ASSERT_TRUE(sandboxJsonManager_->HasRetentionSandboxInfo("testbundle"));
455     retentionInfo.bundleName = "testbundle1";
456     retentionInfo.tokenId = 827818;
457     retentionInfo.userId = 10000;
458     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
459     ASSERT_TRUE(!sandboxJsonManager_->HasRetentionSandboxInfo("testbundle1"));
460 
461     ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, sandboxJsonManager_->DelSandboxInfo(8888));
462 
463     RetentionInfo info;
464     info.tokenId = 827878;
465     std::set<std::string> docUriSet;
466     ASSERT_TRUE(!sandboxJsonManager_->ClearDocUriSet(info, docUriSet));
467     docUriSet.insert("testUri");
468     sandboxJsonManager_->UpdateRetentionState(docUriSet, info, true);
469     ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, sandboxJsonManager_->DelSandboxInfo(827878));
470     sandboxJsonManager_->UpdateRetentionState(docUriSet, info, false);
471     ASSERT_EQ(DLP_OK, sandboxJsonManager_->DelSandboxInfo(827878));
472     setuid(uid);
473 }
474 
475 /**
476  * @tc.name:SandboxJsonManager003
477  * @tc.desc: SandboxJsonManager test
478  * @tc.type: FUNC
479  * @tc.require:DTS2023040302317
480  */
481 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager003, TestSize.Level1)
482 {
483     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
484     RetentionInfo retentionInfo = {
485         .appIndex = 1,
486         .tokenId = 827818,
487         .bundleName = "testbundle1",
488         .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
489         .userId = 10000
490     };
491     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
492     int32_t uid = getuid();
493     ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
494         sandboxJsonManager_->RemoveRetentionState("testbundle", -1));
495     ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
496         sandboxJsonManager_->RemoveRetentionState("testbundle1", -1));
497     retentionInfo.bundleName = "testbundle";
498     retentionInfo.tokenId = 827878;
499     retentionInfo.userId = g_userId;
500     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
501     ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
502         sandboxJsonManager_->RemoveRetentionState("testbundle1", -1));
503     ASSERT_EQ(DLP_OK, sandboxJsonManager_->RemoveRetentionState("testbundle", -1));
504     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
505     ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
506         sandboxJsonManager_->RemoveRetentionState("testbundle", 2));
507     ASSERT_EQ(DLP_OK, sandboxJsonManager_->RemoveRetentionState("testbundle", 1));
508     setuid(uid);
509 }
510 
511 /**
512  * @tc.name:SandboxJsonManager004
513  * @tc.desc: GetBundleNameSetByUserId test
514  * @tc.type: FUNC
515  * @tc.require:DTS2023040302317
516  */
517 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager004, TestSize.Level1)
518 {
519     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
520     std::set<std::string> keySet;
521     int res = sandboxJsonManager_->GetBundleNameSetByUserId(100, keySet);
522     ASSERT_EQ(DLP_OK, res);
523     SandboxInfo sandboxInfo;
524     int32_t ret = dlpPermissionService_->InstallDlpSandbox(
525         DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri1111");
526     ASSERT_EQ(DLP_OK, ret);
527     res = RetentionFileManager::GetInstance().GetBundleNameSetByUserId(100, keySet);
528     ASSERT_EQ(DLP_OK, res);
529     res = RetentionFileManager::GetInstance().RemoveRetentionInfoByUserId(100, keySet);
530     ASSERT_EQ(DLP_OK, res);
531     res = RetentionFileManager::GetInstance().RemoveRetentionInfoByUserId(100, keySet);
532     ASSERT_EQ(DLP_OK, res);
533 }
534 
535 /**
536  * @tc.name:RetentionFileManager001
537  * @tc.desc: RetentionFileManager test
538  * @tc.type: FUNC
539  * @tc.require:DTS2023040302317
540  */
541 HWTEST_F(DlpPermissionServiceTest, RetentionFileManager001, TestSize.Level1)
542 {
543     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
544     RetentionInfo retentionInfo = {
545         .appIndex = 1,
546         .tokenId = 827878,
547         .bundleName = "testbundle",
548         .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
549         .userId = 100
550     };
551     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
552     int32_t uid = getuid();
553     setuid(10031);
554     ASSERT_TRUE(!RetentionFileManager::GetInstance().HasRetentionSandboxInfo("testbundle1"));
555     setuid(20010031);
556     RetentionFileManager::GetInstance().hasInit = false;
557     ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().AddSandboxInfo(retentionInfo));
558     RetentionFileManager::GetInstance().hasInit = false;
559     ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, RetentionFileManager::GetInstance().DelSandboxInfo(8888));
560     RetentionFileManager::GetInstance().hasInit = false;
561     ASSERT_TRUE(RetentionFileManager::GetInstance().CanUninstall(8888));
562     RetentionFileManager::GetInstance().hasInit = false;
563     ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
564         RetentionFileManager::GetInstance().RemoveRetentionState("testbundle1", -1));
565     RetentionFileManager::GetInstance().hasInit = false;
566     ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().ClearUnreservedSandbox());
567     RetentionFileManager::GetInstance().hasInit = false;
568     std::vector<RetentionSandBoxInfo> vec;
569     ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().GetRetentionSandboxList("testbundle1", vec, false));
570 
571     setuid(uid);
572 }
573 
574 /**
575  * @tc.name:InstallDlpSandbox001
576  * @tc.desc:InstallDlpSandbox test
577  * @tc.type: FUNC
578  * @tc.require:DTS2023040302317
579  */
580 HWTEST_F(DlpPermissionServiceTest, InstallDlpSandbox001, TestSize.Level1)
581 {
582     DLP_LOG_DEBUG(LABEL, "InstallDlpSandbox001");
583     SandboxInfo sandboxInfo;
584     int32_t ret = dlpPermissionService_->InstallDlpSandbox(
585         DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri");
586     ASSERT_EQ(DLP_OK, ret);
587     int32_t editAppIndex = sandboxInfo.appIndex;
588     std::set<std::string> docUriSet;
589     docUriSet.insert("testUri");
590     RetentionInfo info;
591     info.appIndex = editAppIndex;
592     info.tokenId = sandboxInfo.tokenId;
593     info.bundleName = DLP_MANAGER_APP;
594     info.userId = DEFAULT_USERID;
595     RetentionFileManager::GetInstance().UpdateSandboxInfo(docUriSet, info, true);
596     ret = dlpPermissionService_->InstallDlpSandbox(
597         DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri");
598     ASSERT_EQ(DLP_OK, ret);
599     ASSERT_EQ(sandboxInfo.appIndex, editAppIndex);
600     ret = dlpPermissionService_->InstallDlpSandbox(
601         DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri");
602     ASSERT_EQ(DLP_OK, ret);
603     editAppIndex = sandboxInfo.appIndex;
604     dlpPermissionService_->InstallDlpSandbox(
605         DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri1");
606     ASSERT_EQ(DLP_OK, ret);
607     ASSERT_EQ(sandboxInfo.appIndex, editAppIndex);
608     editAppIndex = sandboxInfo.appIndex;
609     info.appIndex = editAppIndex;
610     info.tokenId = sandboxInfo.tokenId;
611     RetentionFileManager::GetInstance().UpdateSandboxInfo(docUriSet, info, true);
612     ret = dlpPermissionService_->InstallDlpSandbox(
613         DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri");
614     ASSERT_EQ(DLP_OK, ret);
615     ASSERT_EQ(sandboxInfo.appIndex, editAppIndex);
616 }
617 
618 /**
619  * @tc.name:UninstallDlpSandbox001
620  * @tc.desc:UninstallDlpSandbox test
621  * @tc.type: FUNC
622  * @tc.require:DTS2023040302317
623  */
624 HWTEST_F(DlpPermissionServiceTest, UninstallDlpSandbox001, TestSize.Level1)
625 {
626     SandboxInfo sandboxInfo;
627     uint32_t dlpFileAccess = 5;
628     int32_t ret = dlpPermissionService_->InstallDlpSandbox(
629         "", static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri");
630     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
631     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->InstallDlpSandbox("testbundle",
632         static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri"));
633     dlpFileAccess = 0;
634     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->InstallDlpSandbox("testbundle",
635         static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri"));
636     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("", -1, -1));
637     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("testbundle", -1, -1));
638     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("testbundle", 1, -1));
639 }
640 
641 /**
642  * @tc.name:AppUninstallObserver001
643  * @tc.desc:AppUninstallObserver test
644  * @tc.type: FUNC
645  * @tc.require:DTS2023040302317
646  */
647 HWTEST_F(DlpPermissionServiceTest, AppUninstallObserver001, TestSize.Level1)
648 {
649     EventFwk::CommonEventSubscribeInfo subscribeInfo;
650     std::shared_ptr<AppUninstallObserver> observer_ = std::make_shared<AppUninstallObserver>(subscribeInfo);
651     EventFwk::CommonEventData data;
652     OHOS::AAFwk::Want want;
653     want.SetBundle("testbundle1");
654     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
655     data.SetWant(want);
656     observer_->OnReceiveEvent(data);
657     std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
658     RetentionInfo retentionInfo = {
659         .appIndex = 1,
660         .tokenId = 827818,
661         .bundleName = "testbundle",
662         .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
663         .userId = 100
664     };
665     sandboxJsonManager_->AddSandboxInfo(retentionInfo);
666     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_FULLY_REMOVED);
667     want.SetBundle("testbundle");
668     data.SetWant(want);
669     observer_->OnReceiveEvent(data);
670     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
671     data.SetWant(want);
672     observer_->OnReceiveEvent(data);
673 }
674 
675 class DlpTestRemoteObj : public IRemoteBroker {
676 public:
677     DECLARE_INTERFACE_DESCRIPTOR(u"ohos.dlp.test");
678     DlpTestRemoteObj() = default;
679     virtual ~DlpTestRemoteObj() noexcept = default;
680 };
681 
682 /**
683  * @tc.name:SandboxJsonManager001
684  * @tc.desc: SandboxJsonManager test
685  * @tc.type: FUNC
686  * @tc.require:SR000I38N7
687  */
688 HWTEST_F(DlpPermissionServiceTest, DlpPermissionStub001, TestSize.Level1)
689 {
690     sptr<DlpPermissionStub> stub = new (std::nothrow) DlpPermissionService(0, 0);
691     ASSERT_TRUE(!(stub == nullptr));
692 
693     sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
694     ASSERT_TRUE(!(policyParcel == nullptr));
695 
696     sptr<DlpTestRemoteObj> callback = new (std::nothrow)IRemoteStub<DlpTestRemoteObj>();
697     EXPECT_TRUE(callback != nullptr);
698 
699     int32_t res;
700     MessageParcel data;
701     MessageParcel reply;
702     res = stub->GenerateDlpCertificateInner(data, reply);
703     EXPECT_EQ(false, !res);
704 
705     res = data.WriteParcelable(policyParcel);
706     EXPECT_EQ(false, !res);
707 
708     res = data.WriteRemoteObject(callback->AsObject());
709     EXPECT_EQ(false, !res);
710 
711     res = stub->GenerateDlpCertificateInner(data, reply);
712     EXPECT_EQ(false, !res);
713 
714     sptr<IDlpPermissionCallback> callback2 = nullptr;
715     res = stub->GenerateDlpCertificate(policyParcel, callback2);
716     EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
717 
718     sptr<IDlpPermissionCallback> callback3 = iface_cast<IDlpPermissionCallback>(callback->AsObject());
719     res = stub->GenerateDlpCertificate(policyParcel, callback3);
720     EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
721 }
722 
723 /**
724  * @tc.name: VisitRecordJsonManager001
725  * @tc.desc: VisitRecordJsonManager test
726  * @tc.type: FUNC
727  * @tc.require:SR000I38MU
728  */
729 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager001, TestSize.Level1)
730 {
731     std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
732     std::vector<VisitedDLPFileInfo> infoVec;
733     int32_t res = visitRecordJsonManager_->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
734     ASSERT_EQ(DLP_FILE_NO_NEED_UPDATE, res);
735     res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri");
736     ASSERT_EQ(DLP_OK, res);
737     res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri");
738     ASSERT_EQ(DLP_OK, res);
739     res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testur");
740     ASSERT_EQ(DLP_OK, res);
741     res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 1001, "testuri", 0, 1001);
742     ASSERT_EQ(DLP_OK, res);
743     res = visitRecordJsonManager_->AddVisitRecord(PERMISSION_APP, 100, "testuri");
744     ASSERT_EQ(DLP_OK, res);
745     res = visitRecordJsonManager_->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
746     ASSERT_EQ(DLP_OK, res);
747     res = visitRecordJsonManager_->GetVisitRecordList(PERMISSION_APP, 1001, infoVec);
748     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
749     for (int32_t i = 1; i <= 1024; i++) {
750         res = visitRecordJsonManager_->AddVisitRecord(PERMISSION_APP, 100 + i, "testuri", 0, 100 + i);
751     }
752     ASSERT_EQ(DLP_JSON_UPDATE_ERROR, res);
753 }
754 
755 /**
756  * @tc.name: VisitRecordJsonManager002
757  * @tc.desc: VisitRecordJsonManager test
758  * @tc.type: FUNC
759  * @tc.require:SR000I38MU
760  */
761 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager002, TestSize.Level1)
762 {
763     std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
764     std::string jsonStr = "{\"test\":[]}";
765     Json callbackInfoJson = Json::parse(jsonStr, nullptr, false);
766     visitRecordJsonManager_->FromJson(callbackInfoJson);
767     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
768     jsonStr = "{\"recordList\":[{\"bundleName\":\"\",\"docUri\":\"file://media/file/12\",\"userId\":100}]}";
769     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
770     visitRecordJsonManager_->FromJson(callbackInfoJson);
771     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
772     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId\":100}]}";
773     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
774     visitRecordJsonManager_->FromJson(callbackInfoJson);
775     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
776     jsonStr =
777         "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/12\",\"userId\":-1}]}";
778     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
779     visitRecordJsonManager_->FromJson(callbackInfoJson);
780     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
781     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
782         "12\",\"userId\":100}]}";
783     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
784     visitRecordJsonManager_->FromJson(callbackInfoJson);
785     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
786     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
787         "12\",\"userId\":100,\"timestamp\":-1}]}";
788     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
789     visitRecordJsonManager_->FromJson(callbackInfoJson);
790     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
791     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
792         "12\",\"userId\":100,\"timestamp\":1686844687}]}";
793     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
794     visitRecordJsonManager_->FromJson(callbackInfoJson);
795     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
796     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
797         "12\",\"userId\":100,\"timestamp\":1686844687,\"originalTokenId\":100}]}";
798     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
799     visitRecordJsonManager_->FromJson(callbackInfoJson);
800     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 1);
801 }
802 
803 /**
804  * @tc.name: VisitRecordJsonManager003
805  * @tc.desc: VisitRecordJsonManager test
806  * @tc.type: FUNC
807  * @tc.require:SR000I38MU
808  */
809 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager003, TestSize.Level1)
810 {
811     std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
812     visitRecordJsonManager_->FromJson(NULL);
813     std::string jsonStr = "{\"recordList\":[{\"bundleName1\":\"\"}]}";
814     Json callbackInfoJson = Json::parse(jsonStr, nullptr, false);
815     visitRecordJsonManager_->FromJson(callbackInfoJson);
816     ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
817     jsonStr = "{\"recordList\":[{\"bundleName\":1}]}";
818     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
819     visitRecordJsonManager_->FromJson(callbackInfoJson);
820     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri1\":\"\",\"userId\":100}]}";
821     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
822     visitRecordJsonManager_->FromJson(callbackInfoJson);
823     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":1,\"userId\":100}]}";
824     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
825     visitRecordJsonManager_->FromJson(callbackInfoJson);
826     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId1\":100}]}";
827     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
828     visitRecordJsonManager_->FromJson(callbackInfoJson);
829     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId\":\"100\"}]}";
830     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
831     visitRecordJsonManager_->FromJson(callbackInfoJson);
832     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
833         "12\",\"userId\":100,\"timestamp1\":1686844687}]}";
834     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
835     visitRecordJsonManager_->FromJson(callbackInfoJson);
836     jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
837         "12\",\"userId\":100,\"timestamp\":\"1686844687\"}]}";
838     callbackInfoJson = Json::parse(jsonStr, nullptr, false);
839     visitRecordJsonManager_->FromJson(callbackInfoJson);
840     visitRecordJsonManager_->infoList_.clear();
841     ASSERT_EQ("", visitRecordJsonManager_->ToString());
842 }
843 /**
844  * @tc.name: VisitRecordFileManager001
845  * @tc.desc: VisitRecordFileManager test
846  * @tc.type: FUNC
847  * @tc.require:SR000I38MU
848  */
849 HWTEST_F(DlpPermissionServiceTest, VisitRecordFileManager001, TestSize.Level1)
850 {
851     std::shared_ptr<VisitRecordFileManager> visitRecordFileManager = std::make_shared<VisitRecordFileManager>();
852     std::vector<VisitedDLPFileInfo> infoVec;
853     int32_t res = visitRecordFileManager->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
854     ASSERT_EQ(DLP_OK, res);
855     visitRecordFileManager->hasInit_ = true;
856     ASSERT_EQ(true, visitRecordFileManager->Init());
857     visitRecordFileManager->hasInit_ = false;
858     ASSERT_EQ(true, visitRecordFileManager->Init());
859     ASSERT_EQ(DLP_OK, visitRecordFileManager->UpdateFile(DLP_FILE_NO_NEED_UPDATE));
860     ASSERT_EQ(DLP_JSON_UPDATE_ERROR, visitRecordFileManager->UpdateFile(DLP_JSON_UPDATE_ERROR));
861     visitRecordFileManager->hasInit_ = false;
862     ASSERT_EQ(DLP_OK, visitRecordFileManager->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri"));
863     visitRecordFileManager->hasInit_ = false;
864     res = visitRecordFileManager->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
865     ASSERT_EQ(DLP_OK, res);
866 }
867 
868 /**
869  * @tc.name: GetLocalAccountName001
870  * @tc.desc: GetLocalAccountName test
871  * @tc.type: FUNC
872  * @tc.require:SR000I38MU
873  */
874 HWTEST_F(DlpPermissionServiceTest, GetLocalAccountName001, TestSize.Level1)
875 {
876     char* account = nullptr;
877     ASSERT_EQ(0, GetLocalAccountName(&account, g_userId));
878     ASSERT_EQ(-1, GetLocalAccountName(nullptr, g_userId));
879 }
880 
881 /**
882  * @tc.name: OnStart001
883  * @tc.desc: OnStart test
884  * @tc.type: FUNC
885  * @tc.require:
886  */
887 HWTEST_F(DlpPermissionServiceTest, OnStart001, TestSize.Level1)
888 {
889     auto state = dlpPermissionService_->state_;
890     dlpPermissionService_->state_ = ServiceRunningState::STATE_RUNNING;
891     dlpPermissionService_->OnStart();
892     dlpPermissionService_->state_ = state;
893     dlpPermissionService_->OnStop();
894     ASSERT_EQ(true, dlpPermissionService_->RegisterAppStateObserver());
895 }
896 
897 /**
898  * @tc.name: ParseDlpCertificate001
899  * @tc.desc: ParseDlpCertificate test
900  * @tc.type: FUNC
901  * @tc.require:
902  */
903 HWTEST_F(DlpPermissionServiceTest, ParseDlpCertificate001, TestSize.Level1)
904 {
905     sptr<CertParcel> certParcel = new (std::nothrow) CertParcel();
906     sptr<IDlpPermissionCallback> callback = nullptr;
907     int32_t ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
908     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
909 
910     std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
911         std::make_shared<ClientGenerateDlpCertificateCallback>();
912     callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
913     ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
914     ASSERT_EQ(DLP_CREDENTIAL_ERROR_APPID_NOT_AUTHORIZED, ret);
915 }
916 
917 /**
918  * @tc.name: InsertDlpSandboxInfo001
919  * @tc.desc: InsertDlpSandboxInfo test
920  * @tc.type: FUNC
921  * @tc.require:
922  */
923 HWTEST_F(DlpPermissionServiceTest, InsertDlpSandboxInfo001, TestSize.Level1)
924 {
925     auto appStateObserver = dlpPermissionService_->appStateObserver_;
926     DlpSandboxInfo sandboxInfo;
927     dlpPermissionService_->InsertDlpSandboxInfo(sandboxInfo, false);
928     std::string bundleName;
929     int32_t appIndex = 111;
930     int32_t userId = 111;
931     ASSERT_TRUE(0 == dlpPermissionService_->DeleteDlpSandboxInfo(bundleName, appIndex, userId));
932     dlpPermissionService_->appStateObserver_ = appStateObserver;
933 
934     dlpPermissionService_->InsertDlpSandboxInfo(sandboxInfo, true);
935 }
936 
937 /**
938  * @tc.name: InsertDlpSandboxInfo002
939  * @tc.desc: InsertDlpSandboxInfo test
940  * @tc.type: FUNC
941  * @tc.require:
942  */
943 HWTEST_F(DlpPermissionServiceTest, InsertDlpSandboxInfo002, TestSize.Level1)
944 {
945     std::string bundleName;
946     int32_t appIndex = 111;
947     int32_t userId = 111;
948     ASSERT_TRUE(0 == dlpPermissionService_->DeleteDlpSandboxInfo(bundleName, appIndex, userId));
949 }
950 
951 /**
952  * @tc.name: GenerateDlpCertificate001
953  * @tc.desc: GenerateDlpCertificate test
954  * @tc.type: FUNC
955  * @tc.require:
956  */
957 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate001, TestSize.Level1)
958 {
959     DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate001");
960     sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
961     std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
962         std::make_shared<ClientGenerateDlpCertificateCallback>();
963     sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
964 
965     int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
966     DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate001 1");
967     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
968     PermissionPolicy policy;
969     policy.ownerAccount_ = "testAccount";
970     policy.ownerAccountId_ = "testAccountId";
971     policy.ownerAccountType_ = OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT;
972 
973     AuthUserInfo user;
974     NewUserSample(user);
975     policy.authUsers_.emplace_back(user);
976     policyParcel->policyParams_ = policy;
977     res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
978     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
979 }
980 
981 /**
982  * @tc.name: GenerateDlpCertificate002
983  * @tc.desc: GenerateDlpCertificate test
984  * @tc.type: FUNC
985  * @tc.require:
986  */
987 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate002, TestSize.Level1)
988 {
989     DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate002");
990     sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
991     std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
992         std::make_shared<ClientGenerateDlpCertificateCallback>();
993     sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
994 
995     PermissionPolicy policy;
996     GeneratePolicyParam param = {ACCOUNT_LENGTH, AESKEY_LEN, AESKEY_LEN, USER_NUM, ACCOUNT_LENGTH, AUTH_PERM,
997         DELTA_EXPIRY_TIME, HMACKEY_LEN};
998     GeneratePolicy(policy, param);
999     policyParcel->policyParams_.CopyPermissionPolicy(policy);
1000     int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1001     ASSERT_EQ(DLP_OK, res);
1002 }
1003 
1004 /**
1005  * @tc.name: SerializeEncPolicyData001
1006  * @tc.desc: SerializeEncPolicyData test
1007  * @tc.type: FUNC
1008  * @tc.require:
1009  */
1010 HWTEST_F(DlpPermissionServiceTest, SerializeEncPolicyData001, TestSize.Level1)
1011 {
1012     DLP_LOG_DEBUG(LABEL, "SerializeEncPolicyData001");
1013     uint8_t* encPolicy = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(POLICY_CIPHER.c_str()));
1014     const char* exInfo = "DlpRestorePolicyTest_NormalInput_ExtraInfo";
1015     EncAndDecOptions encAndDecOptions = {
1016         .opt = ALLOW_RECEIVER_DECRYPT_WITHOUT_USE_CLOUD,
1017         .extraInfo = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(exInfo)),
1018         .extraInfoLen = strlen(exInfo)
1019     };
1020     DLP_EncPolicyData encPolicyData = {
1021         .dataLen = 0
1022     };
1023     unordered_json encDataJson;
1024     int32_t res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1025     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1026     encPolicyData.dataLen = DLP_MAX_CERT_SIZE + 1;
1027     res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1028     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1029     encPolicyData.dataLen = POLICY_CIPHER.size();
1030     DLP_LOG_DEBUG(LABEL, "SerializeEncPolicyData001 encData.options.extraInfoLen %{public}d",
1031         encAndDecOptions.extraInfoLen);
1032     encPolicyData.options = encAndDecOptions;
1033     res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1034     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1035     encPolicyData.data = encPolicy;
1036     res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1037     ASSERT_EQ(DLP_OK, res);
1038     unordered_json decDataJson = encDataJson;
1039     encAndDecOptions.extraInfoLen = 0;
1040     encPolicyData.options = encAndDecOptions;
1041     DLP_EncPolicyData decPolicyData;
1042     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1043     ASSERT_EQ(DLP_OK, res);
1044     AccountType tempType;
1045     encDataJson.at(ENC_ACCOUNT_TYPE).get_to(tempType);
1046     decDataJson[ENC_ACCOUNT_TYPE] = "test";
1047     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1048     ASSERT_EQ(DLP_OK, res);
1049     decDataJson.erase(ENC_ACCOUNT_TYPE);
1050     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1051     ASSERT_EQ(DLP_OK, res);
1052     decDataJson[ENC_ACCOUNT_TYPE] = tempType;
1053     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1054     ASSERT_EQ(DLP_OK, res);
1055 }
1056 
1057 /**
1058  * @tc.name: UninstallDlpSandboxApp001
1059  * @tc.desc: UninstallDlpSandboxApp test
1060  * @tc.type: FUNC
1061  * @tc.require:
1062  */
1063 HWTEST_F(DlpPermissionServiceTest, UninstallDlpSandboxApp001, TestSize.Level1)
1064 {
1065     DLP_LOG_DEBUG(LABEL, "UninstallDlpSandboxApp001");
1066 
1067     std::string bundleName;
1068     int32_t appIndex = 0;
1069     int32_t userId = 0;
1070     int32_t ret = dlpPermissionService_->UninstallDlpSandboxApp(bundleName, appIndex, userId);
1071     ASSERT_EQ(DLP_SERVICE_ERROR_UNINSTALL_SANDBOX_FAIL, ret);
1072 }
1073 
1074 /**
1075  * @tc.name: GetSandboxExternalAuthorization001
1076  * @tc.desc: GetSandboxExternalAuthorization test
1077  * @tc.type: FUNC
1078  * @tc.require:
1079  */
1080 HWTEST_F(DlpPermissionServiceTest, GetSandboxExternalAuthorization001, TestSize.Level1)
1081 {
1082     DLP_LOG_DEBUG(LABEL, "GetSandboxExternalAuthorization001");
1083 
1084     int sandboxUid = -1;
1085     AAFwk::Want want;
1086     SandBoxExternalAuthorType authType;
1087     int32_t ret = dlpPermissionService_->GetSandboxExternalAuthorization(sandboxUid, want, authType);
1088     ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
1089     sandboxUid = 0;
1090     ret = dlpPermissionService_->GetSandboxExternalAuthorization(sandboxUid, want, authType);
1091     ASSERT_EQ(DLP_OK, ret);
1092 }
1093 
1094 /**
1095  * @tc.name: GetConfigFileValue001
1096  * @tc.desc: GetConfigFileValue test
1097  * @tc.type: FUNC
1098  * @tc.require:
1099  */
1100 HWTEST_F(DlpPermissionServiceTest, GetConfigFileValue001, TestSize.Level1)
1101 {
1102     DLP_LOG_DEBUG(LABEL, "GetConfigFileValue001");
1103 
1104     std::string cfgFile;
1105     std::vector<std::string> typeList;
1106     (void)dlpPermissionService_->GetConfigFileValue(cfgFile, typeList);
1107 }
1108 
1109 /**
1110  * @tc.name: RemoveRetentionInfo001
1111  * @tc.desc: RemoveRetentionInfo test
1112  * @tc.type: FUNC
1113  * @tc.require:
1114  */
1115 HWTEST_F(DlpPermissionServiceTest, RemoveRetentionInfo001, TestSize.Level1)
1116 {
1117     DLP_LOG_DEBUG(LABEL, "RemoveRetentionInfo001");
1118 
1119     std::vector<RetentionSandBoxInfo> retentionSandBoxInfoVec;
1120     RetentionInfo info;
1121     bool ret = dlpPermissionService_->RemoveRetentionInfo(retentionSandBoxInfoVec, info);
1122     ASSERT_EQ(true, ret);
1123 }
1124 
1125 /**
1126  * @tc.name: DeserializeEncPolicyDataByFirstVersion001
1127  * @tc.desc: DeserializeEncPolicyDataByFirstVersion test
1128  * @tc.type: FUNC
1129  * @tc.require:
1130  */
1131 HWTEST_F(DlpPermissionServiceTest, DeserializeEncPolicyDataByFirstVersion001, TestSize.Level1)
1132 {
1133     DLP_LOG_INFO(LABEL, "DeserializeEncPolicyDataByFirstVersion001");
1134     unordered_json encDataJson = {
1135         { ENC_DATA_LEN, 11 }
1136     };
1137     unordered_json encDataJson2;
1138     DLP_EncPolicyData encData;
1139     std::string ownerAccountId;
1140     int res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1141         encData, ownerAccountId);
1142     ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1143     encDataJson[ENC_DATA] = "1";
1144     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1145         encData, ownerAccountId);
1146     ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1147     encDataJson[EXTRA_INFO] = "1";
1148     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1149         encData, ownerAccountId);
1150     ASSERT_EQ(res, DLP_OK);
1151     encDataJson2[ENC_POLICY] = "1";
1152     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1153         encData, ownerAccountId);
1154     ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1155     encDataJson2[ENC_ACCOUNT_TYPE] = 2;
1156     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1157         encData, ownerAccountId);
1158     ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1159     encDataJson2[EXTRA_INFO] = "1";
1160     res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1161         encData, ownerAccountId);
1162     ASSERT_EQ(res, DLP_OK);
1163 }
1164 
1165 /**
1166  * @tc.name: SandboxConfigOperate001
1167  * @tc.desc: SandboxConfigOperate test
1168  * @tc.type: FUNC
1169  * @tc.require:
1170  */
1171 HWTEST_F(DlpPermissionServiceTest, SandboxConfigOperate001, TestSize.Level1)
1172 {
1173     DLP_LOG_DEBUG(LABEL, "SandboxConfigOperate001");
1174     std::string config;
1175     int32_t ret = dlpPermissionService_->SandboxConfigOperate(config, SandboxConfigOperationEnum::ADD);
1176     ASSERT_NE(DLP_OK, ret);
1177 }
1178 
1179 /**
1180  * @tc.name: SetReadFlag001
1181  * @tc.desc: SetReadFlag test
1182  * @tc.type: FUNC
1183  * @tc.require:
1184  */
1185 HWTEST_F(DlpPermissionServiceTest, SetReadFlag001, TestSize.Level1)
1186 {
1187     DLP_LOG_DEBUG(LABEL, "SetReadFlag001");
1188     uint32_t uid = 0;
1189     int32_t ret = dlpPermissionService_->SetReadFlag(uid);
1190     ASSERT_EQ(DLP_OK, ret);
1191 }
1192 
1193 /**
1194  * @tc.name: SetRetentionState001
1195  * @tc.desc: SetRetentionState test success
1196  * @tc.type: FUNC
1197  * @tc.require:issue：IAIFTY
1198  */
1199 HWTEST_F(DlpPermissionServiceTest, SetRetentionState001, TestSize.Level1)
1200 {
1201     DLP_LOG_DEBUG(LABEL, "SetRetentionState001");
1202 
1203     std::vector<std::string> docUriVec;
1204     docUriVec.push_back("hh");
1205     int32_t uid = IPCSkeleton::GetCallingUid();
1206     int32_t userId;
1207     GetUserIdFromUid(uid, &userId);
1208     DlpSandboxInfo appInfo;
1209     appInfo = {
1210         .uid = uid,
1211         .userId = userId,
1212         .appIndex = 0,
1213         .bundleName = "testbundle1",
1214         .hasRead = false
1215     };
1216     dlpPermissionService_->appStateObserver_->AddSandboxInfo(appInfo);
1217     int32_t ret = dlpPermissionService_->SetRetentionState(docUriVec);
1218     ASSERT_EQ(ret, DLP_OK);
1219 
1220     std::vector<RetentionSandBoxInfo> retentionSandBoxInfoVec;
1221     RetentionSandBoxInfo retentionSandBoxInfo;
1222     retentionSandBoxInfo.appIndex_ = appInfo.appIndex;
1223     retentionSandBoxInfoVec.push_back(retentionSandBoxInfo);
1224     RetentionSandBoxInfo retentionSandBoxInfo1;
1225     retentionSandBoxInfo1.appIndex_ = appInfo.appIndex + 1;
1226     retentionSandBoxInfoVec.push_back(retentionSandBoxInfo1);
1227 
1228     RetentionInfo info;
1229     info.bundleName = appInfo.bundleName;
1230     bool res = dlpPermissionService_->RemoveRetentionInfo(retentionSandBoxInfoVec, info);
1231     ASSERT_TRUE(res);
1232 }
1233