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 constexpr int32_t SA_ID_DLP_PERMISSION_SERVICE = 3521;
61 static const std::string DLP_MANAGER_APP = "com.ohos.dlpmanager";
62 static const std::string PERMISSION_APP = "com.ohos.permissionmanager";
63 const uint32_t ACCOUNT_LENGTH = 20;
64 const uint32_t USER_NUM = 1;
65 const int AUTH_PERM = 1;
66 const int64_t DELTA_EXPIRY_TIME = 200;
67 const uint64_t EXPIRY_TEN_MINUTE = 60 * 10;
68 const uint32_t AESKEY_LEN = 32;
69 const uint32_t HMACKEY_LEN = 32;
70 const std::string ENC_ACCOUNT_TYPE = "accountType";
71 const std::string ENC_DATA_LEN = "encDataLen";
72 const std::string ENC_DATA = "encData";
73 const std::string EXTRA_INFO_LEN = "extraInfoLen";
74 const std::string EXTRA_INFO = "extraInfo";
75 const std::string ENC_POLICY = "encPolicy";
76 static int32_t g_userId = 100;
77 static const uint8_t ARRAY_CHAR_SIZE = 62;
78 static const char CHAR_ARRAY[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
79
80 static const std::string POLICY_CIPHER = "8B6696A5DD160005C9DCAF43025CB240958D1E53D8E54D70DBED8C191411FA60C9B5D491B"
81 "AE3F34F124DBA805736FCBBC175D881818A93A0E07C844E9DF9503641BF2A98EC49BE0BB2"
82 "E75397187D6A3DC9DEED05A341BFBB761C39C906A9E1344E2CB25432B9C190E1948334A3E"
83 "CDB49C4340A7A8977685E4FDB6EB9E329AB5EEB1EEEBAEF158B0442F98C342714553E50477"
84 "040A52AD79068E6BC68A2F0E2E500DA721927EFF985BDDAF7BCF78FA3BEF2730B25EC05458"
85 "0FDB5BB4EBE7294737E8BF53C6F69C93D00FF41581F80DEA67BB5EBD253BC43729CB8B560B"
86 "893154240AC355CDF8381C84A093B39E5CD6CFF5746FD068F8AA1DEDF2C3C2A12AE2A5CDE9"
87 "075C8AE86654AE4C696C7BE8EB4AB67E25008DE09A5218EFA13B59BAFDFB11FFBB6AD637B9"
88 "B02F598FE511910A9C9F614AF0EA8312F62DAA6C2DA9DCAF973321C45139669E2482C2CB09"
89 "4E60361ED2BA908A4C07443251DFD70762E2180FA5E92DA1CE6D9AAF70761382FC1591BF57"
90 "554693AC55F7121757AA3A4827C9016E1FF5A84FB367047EA7BB28B8E19521BA72AE0BB7C3"
91 "192F5B6D6887034C85A08659850DABD211CD18D5295DD60EEB98FB27C3161134D984665658"
92 "3E29E7C166EB1475647889B62448145D146A8A7A777B346AB7476A10209ED8543965EF3ED3"
93 "C3F96C1CBEDA994243E3064975C23F32F4412F42753668E2CC447E88D6D73534B9F8DD4221"
94 "1074D2D819CA235343D012283F30368DE7C3FBC3A90128EF8CFA86C80C5D7167A3CA60B1F5"
95 "93DDAD90BFF1987C9243ACD4463B11B61A87B9953A0CAE8FD93ACC1E0B0140410451E5CD3A"
96 "E6BB61CF5B1004F46782D924D79CE5615084102A19604BF99D38BFA8B837210022B6AB21E4"
97 "33B5D4E23E278C8CB5EC79DAFEF2A39E3175A0FC6921C37345CAF8D0976677924775A620C5"
98 "E63418C6339525433182D8D127816B36B348B781E02DA65ACCBEAE950CFF8579586B18B77A"
99 "9960ADF484881811D6044E3CC68577599194439E43263E4095CD5399679B548CDFD7430CFB"
100 "F67A1AE23B4136931E10032E4CEACC278584B45337CF7C3E4FEA6D0F1424E3CBC490E4C1DF"
101 "FC2927AA3BC5F57471EAA7D12C65064015A25A11D98E25AFCDB1A1DD876A03EADA9CDD015C"
102 "1265A7FDFA9A766BA832F4B9A2B55B73A361D2A7BD68572EB2ABE1B1DC93904CB5ACD09807"
103 "6FE5089AD8DB2F38DF7D0A76C2C87E36C6F6A5E8190EA76F1F8F0B2493F1FDF38B220BEBC5"
104 "554B3038FE83FD7D10C35034CB3D9409AC9F8F762149A4B19CD0B18B87F4251722EFEFB601"
105 "6DDFACBB8E6F9BAFD48FCFE5370B5661EC4218A65246337E1E24B14CE14EB82CE3B553B560"
106 "8A9A94B1E2E7BAC7CC0B315228E870DF25DFBB8F77A916B8B08692A92D9CB5540DCF4AA4CF"
107 "9B196026908";
108
GetCurrentTimeSec(void)109 uint64_t GetCurrentTimeSec(void)
110 {
111 return static_cast<uint64_t>(duration_cast<seconds>(system_clock::now().time_since_epoch()).count());
112 }
113
NewUserSample(AuthUserInfo & user)114 void NewUserSample(AuthUserInfo& user)
115 {
116 user.authAccount = "allowAccountA";
117 user.authPerm = DLPFileAccess::FULL_CONTROL;
118 user.permExpiryTime = GetCurrentTimeSec() + EXPIRY_TEN_MINUTE;
119 user.authAccountType = OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT;
120 }
121
GetRandNum()122 static uint8_t GetRandNum()
123 {
124 uint8_t rand;
125 RAND_bytes(reinterpret_cast<unsigned char *>(&rand), sizeof(rand));
126 return rand;
127 }
128
GenerateRandArray(uint32_t len)129 uint8_t* GenerateRandArray(uint32_t len)
130 {
131 if (len < 1) {
132 DLP_LOG_ERROR(LABEL, "len error");
133 return nullptr;
134 }
135 uint8_t* str = new (std::nothrow) uint8_t[len];
136 if (str == nullptr) {
137 DLP_LOG_ERROR(LABEL, "New memory fail");
138 return nullptr;
139 }
140 for (uint32_t i = 0; i < len; i++) {
141 str[i] = GetRandNum() % 255; // uint8_t range 0 ~ 255
142 }
143 return str;
144 }
145
GenerateRandStr(uint32_t len,std::string & res)146 static void GenerateRandStr(uint32_t len, std::string& res)
147 {
148 for (uint32_t i = 0; i < len; i++) {
149 uint32_t index = GetRandNum() % ARRAY_CHAR_SIZE;
150 DLP_LOG_INFO(LABEL, "%{public}u", index);
151 res.push_back(CHAR_ARRAY[index]);
152 }
153 DLP_LOG_INFO(LABEL, "%{public}s", res.c_str());
154 }
155
156 struct GeneratePolicyParam {
157 uint32_t ownerAccountLen;
158 uint32_t aeskeyLen;
159 uint32_t ivLen;
160 uint32_t userNum;
161 uint32_t authAccountLen;
162 uint32_t authPerm;
163 int64_t deltaTime;
164 uint32_t hmacKeyLen;
165 };
166
GeneratePolicy(PermissionPolicy & encPolicy,GeneratePolicyParam param,DlpAccountType accountType)167 void GeneratePolicy(PermissionPolicy& encPolicy, GeneratePolicyParam param, DlpAccountType accountType)
168 {
169 uint64_t curTime = static_cast<uint64_t>(
170 std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count());
171 GenerateRandStr(param.ownerAccountLen, encPolicy.ownerAccount_);
172 encPolicy.ownerAccountId_ = encPolicy.ownerAccount_;
173 encPolicy.ownerAccountType_ = accountType;
174 uint8_t* key = GenerateRandArray(param.aeskeyLen);
175 encPolicy.SetAeskey(key, param.aeskeyLen);
176 if (key != nullptr) {
177 delete[] key;
178 key = nullptr;
179 }
180 uint8_t* iv = GenerateRandArray(param.ivLen);
181 encPolicy.SetIv(iv, param.ivLen);
182 if (iv != nullptr) {
183 delete[] iv;
184 iv = nullptr;
185 }
186 uint8_t* hmacKey = GenerateRandArray(param.hmacKeyLen);
187 encPolicy.SetHmacKey(hmacKey, param.hmacKeyLen);
188 if (hmacKey != nullptr) {
189 delete[] hmacKey;
190 hmacKey = nullptr;
191 }
192
193 for (uint32_t user = 0; user < param.userNum; ++user) {
194 std::string accountName;
195 GenerateRandStr(param.authAccountLen, accountName);
196 AuthUserInfo perminfo = {.authAccount = accountName,
197 .authPerm = static_cast<DLPFileAccess>(param.authPerm),
198 .permExpiryTime = curTime + param.deltaTime,
199 .authAccountType = OHOS::Security::DlpPermission::DlpAccountType::DOMAIN_ACCOUNT
200 };
201 encPolicy.authUsers_.emplace_back(perminfo);
202 }
203 }
204 }
205
206 namespace OHOS {
207 namespace AccountSA {
GetOsAccountLocalIdFromUid(const int uid,int & id)208 ErrCode OsAccountManager::GetOsAccountLocalIdFromUid(const int uid, int &id)
209 {
210 id = DEFAULT_USERID;
211 return DLP_OK;
212 }
213 }
214 }
215
SetUpTestCase()216 void DlpPermissionServiceTest::SetUpTestCase()
217 {}
218
TearDownTestCase()219 void DlpPermissionServiceTest::TearDownTestCase()
220 {}
221
SetUp()222 void DlpPermissionServiceTest::SetUp()
223 {
224 DLP_LOG_INFO(LABEL, "setup");
225 if (dlpPermissionService_ != nullptr) {
226 return;
227 }
228 dlpPermissionService_ = std::make_shared<DlpPermissionService>(SA_ID_DLP_PERMISSION_SERVICE, true);
229 ASSERT_NE(nullptr, dlpPermissionService_);
230 dlpPermissionService_->appStateObserver_ = new (std::nothrow) AppStateObserver();
231 ASSERT_TRUE(dlpPermissionService_->appStateObserver_ != nullptr);
232 GetUserIdByForegroundAccount(&g_userId);
233 }
234
TearDown()235 void DlpPermissionServiceTest::TearDown()
236 {
237 if (dlpPermissionService_ != nullptr) {
238 dlpPermissionService_->appStateObserver_ = nullptr;
239 }
240 dlpPermissionService_ = nullptr;
241 }
242
243 /**
244 * @tc.name: DumpTest001
245 * @tc.desc: dlp permission service dump test
246 * @tc.type: FUNC
247 * @tc.require:AR000HGIH9
248 */
249 HWTEST_F(DlpPermissionServiceTest, DumpTest001, TestSize.Level1)
250 {
251 DLP_LOG_INFO(LABEL, "DumpTest001");
252 int fd = -1;
253 std::vector<std::u16string> args;
254
255 // fd is 0
256 EXPECT_EQ(ERR_INVALID_VALUE, dlpPermissionService_->Dump(fd, args));
257
258 fd = 1; // 1: std output
259
260 // hidumper
261 EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
262
263 // hidumper -h
264 args.emplace_back(Str8ToStr16("-h"));
265 EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
266
267 args.clear();
268 // hidumper -d
269 args.emplace_back(Str8ToStr16("-d"));
270 EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
271
272 args.clear();
273 // hidumper with not exist param
274 args.emplace_back(Str8ToStr16("-n"));
275 EXPECT_EQ(ERR_OK, dlpPermissionService_->Dump(fd, args));
276
277 args.clear();
278 }
279
280 class DlpSandboxChangeCallbackTest : public DlpSandboxChangeCallbackStub {
281 public:
282 DlpSandboxChangeCallbackTest() = default;
283 virtual ~DlpSandboxChangeCallbackTest() = default;
284
285 void DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo& result) override;
286 };
287
DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo & result)288 void DlpSandboxChangeCallbackTest::DlpSandboxStateChangeCallback(DlpSandboxCallbackInfo& result) {}
289
290 /**
291 * @tc.name:DlpSandboxChangeCallbackDeathRecipient001
292 * @tc.desc: DlpSandboxChangeCallbackDeathRecipient test
293 * @tc.type: FUNC
294 * @tc.require:DTS2023040302317
295 */
296 HWTEST_F(DlpPermissionServiceTest, DlpSandboxChangeCallbackDeathRecipient001, TestSize.Level1)
297 {
298 auto recipient = std::make_shared<DlpSandboxChangeCallbackDeathRecipient>();
299 ASSERT_NE(nullptr, recipient);
300
301 recipient->OnRemoteDied(nullptr); // remote is nullptr
302
303 // backup
304 sptr<IRemoteObject> callback;
305 wptr<IRemoteObject> remote = new (std::nothrow) DlpSandboxChangeCallbackTest();
306 callback = remote.promote();
307 dlpPermissionService_->RegisterDlpSandboxChangeCallback(callback);
308 ASSERT_EQ(static_cast<uint32_t>(1), DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.size());
309 recipient->OnRemoteDied(remote); // remote is not nullptr
310 ASSERT_EQ(static_cast<uint32_t>(0), DlpSandboxChangeCallbackManager::GetInstance().callbackInfoMap_.size());
311 bool result;
312 int32_t res = dlpPermissionService_->UnRegisterDlpSandboxChangeCallback(result);
313 ASSERT_EQ(DLP_CALLBACK_PARAM_INVALID, res);
314 recipient->OnRemoteDied(remote);
315 DlpPermissionServiceTest::permType = -1;
316 dlpPermissionService_->RegisterDlpSandboxChangeCallback(callback);
317 res = dlpPermissionService_->UnRegisterDlpSandboxChangeCallback(result);
318 ASSERT_EQ(DLP_SERVICE_ERROR_PERMISSION_DENY, res);
319 DlpPermissionServiceTest::permType = 0;
320 }
321
322 class TestOpenDlpFileCallback : public OpenDlpFileCallbackStub {
323 public:
TestOpenDlpFileCallback()324 TestOpenDlpFileCallback() {}
~TestOpenDlpFileCallback()325 ~TestOpenDlpFileCallback() {}
326
OnOpenDlpFile(OpenDlpFileCallbackInfo & result)327 void OnOpenDlpFile(OpenDlpFileCallbackInfo& result) override
328 {
329 called_ = true;
330 }
331 bool called_ = false;
332 };
333
334 /**
335 * @tc.name: OpenDlpFileCallbackDeathRecipient001
336 * @tc.desc: OpenDlpFileCallbackDeathRecipient test
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(DlpPermissionServiceTest, OpenDlpFileCallbackDeathRecipient001, TestSize.Level1)
341 {
342 auto recipient = std::make_shared<OpenDlpFileCallbackDeathRecipient>();
343 ASSERT_NE(nullptr, recipient);
344
345 recipient->OnRemoteDied(nullptr); // remote is nullptr
346
347 // backup
348 OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.clear();
349 wptr<IRemoteObject> remote = new (std::nothrow) TestOpenDlpFileCallback();
350 sptr<IRemoteObject> callback = remote.promote();
351 int32_t res = OpenDlpFileCallbackManager::GetInstance().AddCallback(
352 getpid(), DEFAULT_USERID, DLP_MANAGER_APP, callback);
353 EXPECT_EQ(DLP_OK, res);
354 EXPECT_EQ(static_cast<uint32_t>(1), OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.size());
355 recipient->OnRemoteDied(remote); // remote is not nullptr
356 EXPECT_EQ(static_cast<uint32_t>(0), OpenDlpFileCallbackManager::GetInstance().openDlpFileCallbackMap_.size());
357 DlpPermissionServiceTest::isSandbox = false;
358 res = dlpPermissionService_->UnRegisterOpenDlpFileCallback(callback);
359 DlpPermissionServiceTest::isSandbox = true;
360 EXPECT_EQ(DLP_CALLBACK_PARAM_INVALID, res);
361 recipient->OnRemoteDied(remote);
362
363 res = dlpPermissionService_->UnRegisterOpenDlpFileCallback(callback);
364 ASSERT_EQ(DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR, res);
365
366 DlpPermissionServiceTest::isCheckSandbox = false;
367 res = dlpPermissionService_->UnRegisterOpenDlpFileCallback(callback);
368 DlpPermissionServiceTest::isCheckSandbox = true;
369 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
370 }
371
372 /**
373 * @tc.name:FileOperator001
374 * @tc.desc: FileOperator test
375 * @tc.type: FUNC
376 * @tc.require:SR000I38N7
377 */
378 HWTEST_F(DlpPermissionServiceTest, FileOperator001, TestSize.Level1)
379 {
380 std::shared_ptr<FileOperator> fileOperator_ = std::make_shared<FileOperator>();
381 bool result = fileOperator_->IsExistFile("");
382 ASSERT_TRUE(!result);
383 std::string content = "test";
384 result = fileOperator_->IsExistDir("");
385 ASSERT_TRUE(!result);
386 int32_t res = fileOperator_->InputFileByPathAndContent(TEST_URI, content);
387 ASSERT_EQ(DLP_RETENTION_COMMON_FILE_OPEN_FAILED, res);
388 res = fileOperator_->GetFileContentByPath(TEST_URI, content);
389 ASSERT_EQ(DLP_RETENTION_FILE_FIND_FILE_ERROR, res);
390 };
391
392 /**
393 * @tc.name:SandboxJsonManager001
394 * @tc.desc: SandboxJsonManager test
395 * @tc.type: FUNC
396 * @tc.require:SR000I38N7
397 */
398 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager001, TestSize.Level1)
399 {
400 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
401 RetentionInfo retentionInfo = {
402 .appIndex = 1,
403 .tokenId = 123456,
404 .bundleName = "test.bundlName",
405 .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
406 .userId = 100
407 };
408 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
409 int32_t res = sandboxJsonManager_->AddSandboxInfo(retentionInfo);
410 ASSERT_EQ(DLP_INSERT_FILE_ERROR, res);
411 std::set<std::string> docUriSet;
412 docUriSet.emplace("testUri");
413 RetentionInfo info;
414 info.bundleName = "";
415 info.tokenId = 0;
416 res = sandboxJsonManager_->UpdateRetentionState(docUriSet, info, false);
417 ASSERT_EQ(DLP_RETENTION_UPDATE_ERROR, res);
418 }
419
420 /**
421 * @tc.name:CallbackManager001
422 * @tc.desc: DlpSandboxChangeCallbackManager test
423 * @tc.type: FUNC
424 * @tc.require:DTS2023040302317
425 */
426 HWTEST_F(DlpPermissionServiceTest, CallbackManager001, TestSize.Level1)
427 {
428 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().AddCallback(0, nullptr));
429 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(nullptr));
430 bool result;
431 ASSERT_EQ(
432 DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().RemoveCallback(0, result));
433 sptr<IRemoteObject> callback;
434 wptr<IRemoteObject> remote = new (std::nothrow) DlpSandboxChangeCallbackTest();
435 callback = remote.promote();
436 dlpPermissionService_->RegisterDlpSandboxChangeCallback(callback);
437 for (int i = 10000; i < 11024; i++) {
438 DlpSandboxChangeCallbackManager::GetInstance().AddCallback(i, callback);
439 }
440 ASSERT_EQ(
441 DLP_SERVICE_ERROR_VALUE_INVALID, DlpSandboxChangeCallbackManager::GetInstance().AddCallback(11024, callback));
442 DlpSandboxInfo dlpSandboxInfo;
443 dlpSandboxInfo.pid = 1;
444 DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
445 dlpSandboxInfo.pid = 10010;
446 DlpSandboxChangeCallbackManager::GetInstance().ExecuteCallbackAsync(dlpSandboxInfo);
447 }
448
449 /**
450 * @tc.name:SandboxJsonManager002
451 * @tc.desc: SandboxJsonManager test
452 * @tc.type: FUNC
453 * @tc.require:DTS2023040302317
454 */
455 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager002, TestSize.Level1)
456 {
457 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
458 sandboxJsonManager_->FromJson(NULL);
459 RetentionInfo retentionInfo = {
460 .appIndex = 1,
461 .tokenId = 827878,
462 .bundleName = "testbundle",
463 .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
464 .userId = g_userId
465 };
466 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
467 ASSERT_TRUE(!sandboxJsonManager_->HasRetentionSandboxInfo("testbundle1"));
468 int32_t uid = getuid();
469 setuid(20010031);
470 ASSERT_TRUE(sandboxJsonManager_->HasRetentionSandboxInfo("testbundle"));
471 retentionInfo.bundleName = "testbundle1";
472 retentionInfo.tokenId = 827818;
473 retentionInfo.userId = 10000;
474 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
475 ASSERT_TRUE(!sandboxJsonManager_->HasRetentionSandboxInfo("testbundle1"));
476
477 ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, sandboxJsonManager_->DelSandboxInfo(8888));
478
479 RetentionInfo info;
480 info.tokenId = 827878;
481 std::set<std::string> docUriSet;
482 ASSERT_TRUE(!sandboxJsonManager_->ClearDocUriSet(info, docUriSet));
483 docUriSet.insert("testUri");
484 sandboxJsonManager_->UpdateRetentionState(docUriSet, info, true);
485 ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, sandboxJsonManager_->DelSandboxInfo(827878));
486 sandboxJsonManager_->UpdateRetentionState(docUriSet, info, false);
487 ASSERT_EQ(DLP_OK, sandboxJsonManager_->DelSandboxInfo(827878));
488 setuid(uid);
489 }
490
491 /**
492 * @tc.name:SandboxJsonManager003
493 * @tc.desc: SandboxJsonManager test
494 * @tc.type: FUNC
495 * @tc.require:DTS2023040302317
496 */
497 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager003, TestSize.Level1)
498 {
499 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
500 RetentionInfo retentionInfo = {
501 .appIndex = 1,
502 .tokenId = 827818,
503 .bundleName = "testbundle1",
504 .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
505 .userId = 10000
506 };
507 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
508 int32_t uid = getuid();
509 ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
510 sandboxJsonManager_->RemoveRetentionState("testbundle", -1));
511 ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
512 sandboxJsonManager_->RemoveRetentionState("testbundle1", -1));
513 retentionInfo.bundleName = "testbundle";
514 retentionInfo.tokenId = 827878;
515 retentionInfo.userId = g_userId;
516 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
517 ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
518 sandboxJsonManager_->RemoveRetentionState("testbundle1", -1));
519 ASSERT_EQ(DLP_OK, sandboxJsonManager_->RemoveRetentionState("testbundle", -1));
520 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
521 ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
522 sandboxJsonManager_->RemoveRetentionState("testbundle", 2));
523 ASSERT_EQ(DLP_OK, sandboxJsonManager_->RemoveRetentionState("testbundle", 1));
524 setuid(uid);
525 }
526
527 /**
528 * @tc.name:SandboxJsonManager004
529 * @tc.desc: GetBundleNameSetByUserId test
530 * @tc.type: FUNC
531 * @tc.require:DTS2023040302317
532 */
533 HWTEST_F(DlpPermissionServiceTest, SandboxJsonManager004, TestSize.Level1)
534 {
535 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
536 std::set<std::string> keySet;
537 int res = sandboxJsonManager_->GetBundleNameSetByUserId(100, keySet);
538 ASSERT_EQ(DLP_OK, res);
539 SandboxInfo sandboxInfo;
540 res = dlpPermissionService_->InstallDlpSandbox(
541 DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri1111");
542 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, res);
543 res = RetentionFileManager::GetInstance().GetBundleNameSetByUserId(100, keySet);
544 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, res);
545 res = RetentionFileManager::GetInstance().RemoveRetentionInfoByUserId(100, keySet);
546 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, res);
547 res = RetentionFileManager::GetInstance().RemoveRetentionInfoByUserId(100, keySet);
548 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, res);
549 }
550
551 /**
552 * @tc.name:RetentionFileManager001
553 * @tc.desc: RetentionFileManager test
554 * @tc.type: FUNC
555 * @tc.require:DTS2023040302317
556 */
557 HWTEST_F(DlpPermissionServiceTest, RetentionFileManager001, TestSize.Level1)
558 {
559 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
560 RetentionInfo retentionInfo = {
561 .appIndex = 1,
562 .tokenId = 827878,
563 .bundleName = "testbundle",
564 .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
565 .userId = 100
566 };
567 sandboxJsonManager_->AddSandboxInfo(retentionInfo);
568 int32_t uid = getuid();
569 setuid(10031);
570 ASSERT_TRUE(!RetentionFileManager::GetInstance().HasRetentionSandboxInfo("testbundle1"));
571 setuid(20010031);
572 RetentionFileManager::GetInstance().hasInit_ = false;
573 ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().AddSandboxInfo(retentionInfo));
574 RetentionFileManager::GetInstance().hasInit_ = false;
575 ASSERT_EQ(DLP_RETENTION_SERVICE_ERROR, RetentionFileManager::GetInstance().DelSandboxInfo(8888));
576 RetentionFileManager::GetInstance().hasInit_ = false;
577 ASSERT_TRUE(RetentionFileManager::GetInstance().CanUninstall(8888));
578 RetentionFileManager::GetInstance().hasInit_ = false;
579 ASSERT_EQ(DLP_RETENTION_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY,
580 RetentionFileManager::GetInstance().RemoveRetentionState("testbundle1", -1));
581 RetentionFileManager::GetInstance().hasInit_ = false;
582 ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().ClearUnreservedSandbox());
583 RetentionFileManager::GetInstance().hasInit_ = false;
584 std::vector<RetentionSandBoxInfo> vec;
585 ASSERT_EQ(DLP_OK, RetentionFileManager::GetInstance().GetRetentionSandboxList("testbundle1", vec, false));
586
587 setuid(uid);
588 }
589
590 /**
591 * @tc.name:InstallDlpSandbox001
592 * @tc.desc:InstallDlpSandbox test
593 * @tc.type: FUNC
594 * @tc.require:DTS2023040302317
595 */
596 HWTEST_F(DlpPermissionServiceTest, InstallDlpSandbox001, TestSize.Level1)
597 {
598 DLP_LOG_DEBUG(LABEL, "InstallDlpSandbox001");
599 SandboxInfo sandboxInfo;
600 int32_t ret = dlpPermissionService_->InstallDlpSandbox(
601 DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri");
602 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
603 int32_t editAppIndex = sandboxInfo.appIndex;
604 std::set<std::string> docUriSet;
605 docUriSet.insert("testUri");
606 RetentionInfo info;
607 info.appIndex = editAppIndex;
608 info.tokenId = sandboxInfo.tokenId;
609 info.bundleName = DLP_MANAGER_APP;
610 info.userId = DEFAULT_USERID;
611 RetentionFileManager::GetInstance().UpdateSandboxInfo(docUriSet, info, true);
612 ret = dlpPermissionService_->InstallDlpSandbox(
613 DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri");
614 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
615 ret = dlpPermissionService_->InstallDlpSandbox(
616 DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri");
617 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
618 editAppIndex = sandboxInfo.appIndex;
619 dlpPermissionService_->InstallDlpSandbox(
620 DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri1");
621 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
622 editAppIndex = sandboxInfo.appIndex;
623 info.appIndex = editAppIndex;
624 info.tokenId = sandboxInfo.tokenId;
625 RetentionFileManager::GetInstance().UpdateSandboxInfo(docUriSet, info, true);
626 ret = dlpPermissionService_->InstallDlpSandbox(
627 DLP_MANAGER_APP, DLPFileAccess::READ_ONLY, DEFAULT_USERID, sandboxInfo, "testUri");
628 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
629 }
630
631 /**
632 * @tc.name:InstallDlpSandbox002
633 * @tc.desc:InstallDlpSandbox test
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(DlpPermissionServiceTest, InstallDlpSandbox002, TestSize.Level1)
638 {
639 DLP_LOG_DEBUG(LABEL, "InstallDlpSandbox002");
640 SandboxInfo sandboxInfo;
641 DlpPermissionServiceTest::permType = -1;
642 int32_t ret = dlpPermissionService_->InstallDlpSandbox(
643 DLP_MANAGER_APP, DLPFileAccess::CONTENT_EDIT, DEFAULT_USERID, sandboxInfo, "testUri");
644 DlpPermissionServiceTest::permType = 0;
645 ASSERT_EQ(DLP_SERVICE_ERROR_PERMISSION_DENY, ret);
646 }
647
648 /**
649 * @tc.name:UninstallDlpSandbox001
650 * @tc.desc:UninstallDlpSandbox test
651 * @tc.type: FUNC
652 * @tc.require:DTS2023040302317
653 */
654 HWTEST_F(DlpPermissionServiceTest, UninstallDlpSandbox001, TestSize.Level1)
655 {
656 SandboxInfo sandboxInfo;
657 uint32_t dlpFileAccess = 5;
658 int32_t ret = dlpPermissionService_->InstallDlpSandbox(
659 "", static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri");
660 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
661 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->InstallDlpSandbox("testbundle",
662 static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri"));
663 dlpFileAccess = 0;
664 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->InstallDlpSandbox("testbundle",
665 static_cast<DLPFileAccess>(dlpFileAccess), 100, sandboxInfo, "testUri"));
666 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("", -1, -1));
667 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("testbundle", -1, -1));
668 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, dlpPermissionService_->UninstallDlpSandbox("testbundle", 1, -1));
669 }
670
671 /**
672 * @tc.name:UninstallDlpSandbox002
673 * @tc.desc:UninstallDlpSandbox test
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(DlpPermissionServiceTest, UninstallDlpSandbox002, TestSize.Level1)
678 {
679 DlpPermissionServiceTest::permType = -1;
680 int32_t ret = dlpPermissionService_->UninstallDlpSandbox("", -1, -1);
681 DlpPermissionServiceTest::permType = 0;
682 ASSERT_EQ(DLP_SERVICE_ERROR_PERMISSION_DENY, ret);
683 }
684
685 /**
686 * @tc.name:AppUninstallObserver001
687 * @tc.desc:AppUninstallObserver test
688 * @tc.type: FUNC
689 * @tc.require:DTS2023040302317
690 */
691 HWTEST_F(DlpPermissionServiceTest, AppUninstallObserver001, TestSize.Level1)
692 {
693 EventFwk::CommonEventSubscribeInfo subscribeInfo;
694 std::shared_ptr<AppUninstallObserver> observer_ = std::make_shared<AppUninstallObserver>(subscribeInfo);
695 EventFwk::CommonEventData data;
696 OHOS::AAFwk::Want want;
697 want.SetBundle("testbundle1");
698 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
699 data.SetWant(want);
700 observer_->OnReceiveEvent(data);
701 std::shared_ptr<SandboxJsonManager> sandboxJsonManager_ = std::make_shared<SandboxJsonManager>();
702 RetentionInfo retentionInfo = {
703 .appIndex = 1,
704 .tokenId = 827818,
705 .bundleName = "testbundle",
706 .dlpFileAccess = DLPFileAccess::CONTENT_EDIT,
707 .userId = 100
708 };
709 int32_t ret = sandboxJsonManager_->AddSandboxInfo(retentionInfo);
710 ASSERT_EQ(DLP_OK, ret);
711 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_FULLY_REMOVED);
712 want.SetBundle("testbundle");
713 data.SetWant(want);
714 observer_->OnReceiveEvent(data);
715 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
716 data.SetWant(want);
717 observer_->OnReceiveEvent(data);
718 }
719
720 class DlpTestRemoteObj : public IRemoteBroker {
721 public:
722 DECLARE_INTERFACE_DESCRIPTOR(u"ohos.dlp.test");
723 DlpTestRemoteObj() = default;
724 virtual ~DlpTestRemoteObj() noexcept = default;
725 };
726
727 /**
728 * @tc.name:SandboxJsonManager001
729 * @tc.desc: SandboxJsonManager test
730 * @tc.type: FUNC
731 * @tc.require:SR000I38N7
732 */
733 HWTEST_F(DlpPermissionServiceTest, DlpPermissionStub001, TestSize.Level1)
734 {
735 sptr<DlpPermissionServiceStub> stub = new (std::nothrow) DlpPermissionService(0, 0);
736 ASSERT_TRUE(!(stub == nullptr));
737
738 sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
739 ASSERT_TRUE(!(policyParcel == nullptr));
740
741 sptr<DlpTestRemoteObj> callback = new (std::nothrow)IRemoteStub<DlpTestRemoteObj>();
742 EXPECT_TRUE(callback != nullptr);
743
744 int32_t res;
745 MessageParcel data;
746 MessageParcel reply;
747 MessageOption option;
748 res = stub->OnRemoteRequest(static_cast<uint32_t>(IDlpPermissionServiceIpcCode::COMMAND_GENERATE_DLP_CERTIFICATE),
749 data, reply, option);
750 EXPECT_EQ(false, !res);
751
752 res = data.WriteParcelable(policyParcel);
753 EXPECT_EQ(false, res);
754
755 res = data.WriteRemoteObject(callback->AsObject());
756 EXPECT_EQ(false, !res);
757
758 res = stub->OnRemoteRequest(static_cast<uint32_t>(IDlpPermissionServiceIpcCode::COMMAND_GENERATE_DLP_CERTIFICATE),
759 data, reply, option);
760 EXPECT_EQ(false, !res);
761
762 sptr<IDlpPermissionCallback> callback2 = nullptr;
763 res = stub->GenerateDlpCertificate(policyParcel, callback2);
764 EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
765
766 sptr<IDlpPermissionCallback> callback3 = iface_cast<IDlpPermissionCallback>(callback->AsObject());
767 res = stub->GenerateDlpCertificate(policyParcel, callback3);
768 EXPECT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
769 }
770
771 /**
772 * @tc.name: VisitRecordJsonManager001
773 * @tc.desc: VisitRecordJsonManager test
774 * @tc.type: FUNC
775 * @tc.require:SR000I38MU
776 */
777 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager001, TestSize.Level1)
778 {
779 std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
780 std::vector<VisitedDLPFileInfo> infoVec;
781 int32_t res = visitRecordJsonManager_->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
782 ASSERT_EQ(DLP_FILE_NO_NEED_UPDATE, res);
783 res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri");
784 if (res != DLP_OK) {
785 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
786 } else {
787 ASSERT_EQ(DLP_OK, res);
788 }
789
790 res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri");
791 if (res != DLP_OK) {
792 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
793 } else {
794 ASSERT_EQ(DLP_OK, res);
795 }
796 res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 100, "testur");
797 if (res != DLP_OK) {
798 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
799 } else {
800 ASSERT_EQ(DLP_OK, res);
801 }
802 res = visitRecordJsonManager_->AddVisitRecord(DLP_MANAGER_APP, 1001, "testuri", 0, 1001);
803 if (res != DLP_OK) {
804 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
805 } else {
806 ASSERT_EQ(DLP_OK, res);
807 }
808 res = visitRecordJsonManager_->AddVisitRecord(PERMISSION_APP, 100, "testuri");
809 if (res != DLP_OK) {
810 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
811 } else {
812 ASSERT_EQ(DLP_OK, res);
813 }
814 res = visitRecordJsonManager_->GetVisitRecordList(PERMISSION_APP, 1001, infoVec);
815 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
816 for (int32_t i = 1; i <= 1024; i++) {
817 res = visitRecordJsonManager_->AddVisitRecord(PERMISSION_APP, 100 + i, "testuri", 0, 100 + i);
818 }
819 if (res != DLP_JSON_UPDATE_ERROR) {
820 ASSERT_NE(DLP_SERVICE_ERROR_VALUE_INVALID, res);
821 } else {
822 ASSERT_EQ(DLP_JSON_UPDATE_ERROR, res);
823 }
824 }
825
826 /**
827 * @tc.name: VisitRecordJsonManager002
828 * @tc.desc: VisitRecordJsonManager test
829 * @tc.type: FUNC
830 * @tc.require:SR000I38MU
831 */
832 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager002, TestSize.Level1)
833 {
834 std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
835 std::string jsonStr = "{\"test\":[]}";
836 Json callbackInfoJson = Json::parse(jsonStr, nullptr, false);
837 visitRecordJsonManager_->FromJson(callbackInfoJson);
838 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
839 jsonStr = "{\"recordList\":[{\"bundleName\":\"\",\"docUri\":\"file://media/file/12\",\"userId\":100}]}";
840 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
841 visitRecordJsonManager_->FromJson(callbackInfoJson);
842 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
843 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId\":100}]}";
844 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
845 visitRecordJsonManager_->FromJson(callbackInfoJson);
846 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
847 jsonStr =
848 "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/12\",\"userId\":-1}]}";
849 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
850 visitRecordJsonManager_->FromJson(callbackInfoJson);
851 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
852 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
853 "12\",\"userId\":100}]}";
854 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
855 visitRecordJsonManager_->FromJson(callbackInfoJson);
856 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
857 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
858 "12\",\"userId\":100,\"timestamp\":-1}]}";
859 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
860 visitRecordJsonManager_->FromJson(callbackInfoJson);
861 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
862 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
863 "12\",\"userId\":100,\"timestamp\":1686844687}]}";
864 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
865 visitRecordJsonManager_->FromJson(callbackInfoJson);
866 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
867 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
868 "12\",\"userId\":100,\"timestamp\":1686844687,\"originalTokenId\":100}]}";
869 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
870 visitRecordJsonManager_->FromJson(callbackInfoJson);
871 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 1);
872 }
873
874 /**
875 * @tc.name: VisitRecordJsonManager003
876 * @tc.desc: VisitRecordJsonManager test
877 * @tc.type: FUNC
878 * @tc.require:SR000I38MU
879 */
880 HWTEST_F(DlpPermissionServiceTest, VisitRecordJsonManager003, TestSize.Level1)
881 {
882 std::shared_ptr<VisitRecordJsonManager> visitRecordJsonManager_ = std::make_shared<VisitRecordJsonManager>();
883 visitRecordJsonManager_->FromJson(NULL);
884 std::string jsonStr = "{\"recordList\":[{\"bundleName1\":\"\"}]}";
885 Json callbackInfoJson = Json::parse(jsonStr, nullptr, false);
886 visitRecordJsonManager_->FromJson(callbackInfoJson);
887 ASSERT_TRUE(visitRecordJsonManager_->infoList_.size() == 0);
888 jsonStr = "{\"recordList\":[{\"bundleName\":1}]}";
889 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
890 visitRecordJsonManager_->FromJson(callbackInfoJson);
891 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri1\":\"\",\"userId\":100}]}";
892 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
893 visitRecordJsonManager_->FromJson(callbackInfoJson);
894 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":1,\"userId\":100}]}";
895 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
896 visitRecordJsonManager_->FromJson(callbackInfoJson);
897 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId1\":100}]}";
898 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
899 visitRecordJsonManager_->FromJson(callbackInfoJson);
900 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"\",\"userId\":\"100\"}]}";
901 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
902 visitRecordJsonManager_->FromJson(callbackInfoJson);
903 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
904 "12\",\"userId\":100,\"timestamp1\":1686844687}]}";
905 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
906 visitRecordJsonManager_->FromJson(callbackInfoJson);
907 jsonStr = "{\"recordList\":[{\"bundleName\":\"com.example.ohnotes\",\"docUri\":\"file://media/file/"
908 "12\",\"userId\":100,\"timestamp\":\"1686844687\"}]}";
909 callbackInfoJson = Json::parse(jsonStr, nullptr, false);
910 visitRecordJsonManager_->FromJson(callbackInfoJson);
911 visitRecordJsonManager_->infoList_.clear();
912 ASSERT_EQ("", visitRecordJsonManager_->ToString());
913 }
914 /**
915 * @tc.name: VisitRecordFileManager001
916 * @tc.desc: VisitRecordFileManager test
917 * @tc.type: FUNC
918 * @tc.require:SR000I38MU
919 */
920 HWTEST_F(DlpPermissionServiceTest, VisitRecordFileManager001, TestSize.Level1)
921 {
922 std::shared_ptr<VisitRecordFileManager> visitRecordFileManager = std::make_shared<VisitRecordFileManager>();
923 std::vector<VisitedDLPFileInfo> infoVec;
924 int32_t res = visitRecordFileManager->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
925 ASSERT_EQ(DLP_OK, res);
926 visitRecordFileManager->hasInit_ = true;
927 ASSERT_EQ(true, visitRecordFileManager->Init());
928 visitRecordFileManager->hasInit_ = false;
929 ASSERT_EQ(true, visitRecordFileManager->Init());
930 ASSERT_EQ(DLP_OK, visitRecordFileManager->UpdateFile(DLP_FILE_NO_NEED_UPDATE));
931 ASSERT_EQ(DLP_JSON_UPDATE_ERROR, visitRecordFileManager->UpdateFile(DLP_JSON_UPDATE_ERROR));
932 visitRecordFileManager->hasInit_ = false;
933 res = visitRecordFileManager->AddVisitRecord(DLP_MANAGER_APP, 100, "testuri");
934 if (res != DLP_OK) {
935 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
936 } else {
937 ASSERT_EQ(DLP_OK, res);
938 }
939 visitRecordFileManager->hasInit_ = false;
940 res = visitRecordFileManager->GetVisitRecordList(DLP_MANAGER_APP, 100, infoVec);
941 ASSERT_EQ(DLP_OK, res);
942 }
943
944 /**
945 * @tc.name: GetLocalAccountName001
946 * @tc.desc: GetLocalAccountName test
947 * @tc.type: FUNC
948 * @tc.require:SR000I38MU
949 */
950 HWTEST_F(DlpPermissionServiceTest, GetLocalAccountName001, TestSize.Level1)
951 {
952 ASSERT_EQ(-1, GetLocalAccountName(nullptr, g_userId));
953 }
954
955 /**
956 * @tc.name: OnStart001
957 * @tc.desc: OnStart test
958 * @tc.type: FUNC
959 * @tc.require:
960 */
961 HWTEST_F(DlpPermissionServiceTest, OnStart001, TestSize.Level1)
962 {
963 auto state = dlpPermissionService_->state_;
964 dlpPermissionService_->state_ = ServiceRunningState::STATE_RUNNING;
965 dlpPermissionService_->OnStart();
966 dlpPermissionService_->state_ = state;
967 dlpPermissionService_->OnStop();
968 ASSERT_EQ(true, dlpPermissionService_->RegisterAppStateObserver());
969 }
970
971 /**
972 * @tc.name: ParseDlpCertificate001
973 * @tc.desc: ParseDlpCertificate test
974 * @tc.type: FUNC
975 * @tc.require:
976 */
977 HWTEST_F(DlpPermissionServiceTest, ParseDlpCertificate001, TestSize.Level1)
978 {
979 sptr<CertParcel> certParcel = new (std::nothrow) CertParcel();
980 sptr<IDlpPermissionCallback> callback = nullptr;
981 int32_t ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
982 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
983
984 std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
985 std::make_shared<ClientGenerateDlpCertificateCallback>();
986 callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
987 ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
988 ASSERT_EQ(DLP_CREDENTIAL_ERROR_APPID_NOT_AUTHORIZED, ret);
989 }
990
991 /**
992 * @tc.name: ParseDlpCertificate002
993 * @tc.desc: ParseDlpCertificate test
994 * @tc.type: FUNC
995 * @tc.require:
996 */
997 HWTEST_F(DlpPermissionServiceTest, ParseDlpCertificate002, TestSize.Level1)
998 {
999 sptr<CertParcel> certParcel = new (std::nothrow) CertParcel();
1000 sptr<IDlpPermissionCallback> callback = nullptr;
1001 DlpPermissionServiceTest::permType = 1;
1002 int32_t ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
1003 DlpPermissionServiceTest::permType = 0;
1004 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
1005
1006 DlpPermissionServiceTest::permType = 2;
1007 ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
1008 DlpPermissionServiceTest::permType = 0;
1009 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
1010
1011 DlpPermissionServiceTest::permType = -1;
1012 ret = dlpPermissionService_->ParseDlpCertificate(certParcel, callback, "", true);
1013 DlpPermissionServiceTest::permType = 0;
1014 ASSERT_EQ(DLP_SERVICE_ERROR_PERMISSION_DENY, ret);
1015 }
1016
1017 /**
1018 * @tc.name: InsertDlpSandboxInfo001
1019 * @tc.desc: InsertDlpSandboxInfo test
1020 * @tc.type: FUNC
1021 * @tc.require:
1022 */
1023 HWTEST_F(DlpPermissionServiceTest, InsertDlpSandboxInfo001, TestSize.Level1)
1024 {
1025 auto appStateObserver = dlpPermissionService_->appStateObserver_;
1026 DlpSandboxInfo sandboxInfo;
1027 dlpPermissionService_->InsertDlpSandboxInfo(sandboxInfo, false);
1028 std::string bundleName;
1029 int32_t appIndex = 111;
1030 int32_t userId = 111;
1031 ASSERT_TRUE(0 == dlpPermissionService_->DeleteDlpSandboxInfo(bundleName, appIndex, userId));
1032 dlpPermissionService_->appStateObserver_ = appStateObserver;
1033
1034 dlpPermissionService_->InsertDlpSandboxInfo(sandboxInfo, true);
1035 }
1036
1037 /**
1038 * @tc.name: InsertDlpSandboxInfo002
1039 * @tc.desc: InsertDlpSandboxInfo test
1040 * @tc.type: FUNC
1041 * @tc.require:
1042 */
1043 HWTEST_F(DlpPermissionServiceTest, InsertDlpSandboxInfo002, TestSize.Level1)
1044 {
1045 std::string bundleName;
1046 int32_t appIndex = 111;
1047 int32_t userId = 111;
1048 ASSERT_TRUE(0 == dlpPermissionService_->DeleteDlpSandboxInfo(bundleName, appIndex, userId));
1049 }
1050
1051 /**
1052 * @tc.name: GenerateDlpCertificate001
1053 * @tc.desc: GenerateDlpCertificate test
1054 * @tc.type: FUNC
1055 * @tc.require:
1056 */
1057 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate001, TestSize.Level1)
1058 {
1059 DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate001");
1060 sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
1061 std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
1062 std::make_shared<ClientGenerateDlpCertificateCallback>();
1063 sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
1064
1065 int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1066 DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate001 1");
1067 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1068 PermissionPolicy policy;
1069 policy.ownerAccount_ = "testAccount";
1070 policy.ownerAccountId_ = "testAccountId";
1071 policy.ownerAccountType_ = OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT;
1072
1073 AuthUserInfo user;
1074 NewUserSample(user);
1075 policy.authUsers_.emplace_back(user);
1076 policyParcel->policyParams_ = policy;
1077 res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1078 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1079 }
1080
1081 /**
1082 * @tc.name: GenerateDlpCertificate002
1083 * @tc.desc: GenerateDlpCertificate test
1084 * @tc.type: FUNC
1085 * @tc.require:
1086 */
1087 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate002, TestSize.Level1)
1088 {
1089 DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate002");
1090 sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
1091 std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
1092 std::make_shared<ClientGenerateDlpCertificateCallback>();
1093 sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
1094
1095 PermissionPolicy policy;
1096 GeneratePolicyParam param = {ACCOUNT_LENGTH, AESKEY_LEN, AESKEY_LEN, USER_NUM, ACCOUNT_LENGTH, AUTH_PERM,
1097 DELTA_EXPIRY_TIME, HMACKEY_LEN};
1098 GeneratePolicy(policy, param, OHOS::Security::DlpPermission::DlpAccountType::DOMAIN_ACCOUNT);
1099 policyParcel->policyParams_.CopyPermissionPolicy(policy);
1100 int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1101 ASSERT_EQ(DLP_PARSE_ERROR_ACCOUNT_INVALID, res);
1102 }
1103
1104 /**
1105 * @tc.name: GenerateDlpCertificate003
1106 * @tc.desc: GenerateDlpCertificate test
1107 * @tc.type: FUNC
1108 * @tc.require:
1109 */
1110 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate003, TestSize.Level1)
1111 {
1112 DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate003");
1113 sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
1114 std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
1115 std::make_shared<ClientGenerateDlpCertificateCallback>();
1116 sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
1117
1118 PermissionPolicy policy;
1119 GeneratePolicyParam param = {ACCOUNT_LENGTH, AESKEY_LEN, AESKEY_LEN, USER_NUM, ACCOUNT_LENGTH, AUTH_PERM,
1120 DELTA_EXPIRY_TIME, HMACKEY_LEN};
1121 GeneratePolicy(policy, param, OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT);
1122 policyParcel->policyParams_.CopyPermissionPolicy(policy);
1123 int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1124 ASSERT_EQ(DLP_OK, res);
1125 }
1126
1127 /**
1128 * @tc.name: GenerateDlpCertificate004
1129 * @tc.desc: GenerateDlpCertificate test
1130 * @tc.type: FUNC
1131 * @tc.require:
1132 */
1133 HWTEST_F(DlpPermissionServiceTest, GenerateDlpCertificate004, TestSize.Level1)
1134 {
1135 DLP_LOG_DEBUG(LABEL, "GenerateDlpCertificate004");
1136 sptr<DlpPolicyParcel> policyParcel = new (std::nothrow) DlpPolicyParcel();
1137 std::shared_ptr<GenerateDlpCertificateCallback> callback1 =
1138 std::make_shared<ClientGenerateDlpCertificateCallback>();
1139 sptr<IDlpPermissionCallback> callback = new (std::nothrow) DlpPermissionAsyncStub(callback1);
1140
1141 PermissionPolicy policy;
1142 GeneratePolicyParam param = {ACCOUNT_LENGTH, AESKEY_LEN, AESKEY_LEN, USER_NUM, ACCOUNT_LENGTH, AUTH_PERM,
1143 DELTA_EXPIRY_TIME, HMACKEY_LEN};
1144 GeneratePolicy(policy, param, OHOS::Security::DlpPermission::DlpAccountType::CLOUD_ACCOUNT);
1145 policyParcel->policyParams_.CopyPermissionPolicy(policy);
1146 DlpPermissionServiceTest::permType = 1;
1147 int32_t res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1148 DlpPermissionServiceTest::permType = 0;
1149 ASSERT_EQ(DLP_OK, res);
1150
1151 DlpPermissionServiceTest::permType = 2;
1152 res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1153 DlpPermissionServiceTest::permType = 0;
1154 ASSERT_EQ(DLP_OK, res);
1155
1156 DlpPermissionServiceTest::permType = -1;
1157 res = dlpPermissionService_->GenerateDlpCertificate(policyParcel, callback);
1158 DlpPermissionServiceTest::permType = 0;
1159 ASSERT_EQ(DLP_SERVICE_ERROR_PERMISSION_DENY, res);
1160 }
1161
1162 /**
1163 * @tc.name: SerializeEncPolicyData001
1164 * @tc.desc: SerializeEncPolicyData test
1165 * @tc.type: FUNC
1166 * @tc.require:
1167 */
1168 HWTEST_F(DlpPermissionServiceTest, SerializeEncPolicyData001, TestSize.Level1)
1169 {
1170 DLP_LOG_DEBUG(LABEL, "SerializeEncPolicyData001");
1171 uint8_t* encPolicy = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(POLICY_CIPHER.c_str()));
1172 const char* exInfo = "DlpRestorePolicyTest_NormalInput_ExtraInfo";
1173 EncAndDecOptions encAndDecOptions = {
1174 .opt = ALLOW_RECEIVER_DECRYPT_WITHOUT_USE_CLOUD,
1175 .extraInfo = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(exInfo)),
1176 .extraInfoLen = strlen(exInfo)
1177 };
1178 DLP_EncPolicyData encPolicyData = {
1179 .dataLen = 0
1180 };
1181 unordered_json encDataJson;
1182 int32_t res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1183 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1184 encPolicyData.dataLen = DLP_MAX_CERT_SIZE + 1;
1185 res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1186 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1187 encPolicyData.dataLen = POLICY_CIPHER.size();
1188 DLP_LOG_DEBUG(LABEL, "SerializeEncPolicyData001 encData.options.extraInfoLen %{public}d",
1189 encAndDecOptions.extraInfoLen);
1190 encPolicyData.options = encAndDecOptions;
1191 res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1192 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, res);
1193 encPolicyData.data = encPolicy;
1194 res = DlpPermissionSerializer::GetInstance().SerializeEncPolicyData(encPolicyData, encDataJson);
1195 ASSERT_EQ(DLP_OK, res);
1196 unordered_json decDataJson = encDataJson;
1197 encAndDecOptions.extraInfoLen = 0;
1198 encPolicyData.options = encAndDecOptions;
1199 DLP_EncPolicyData decPolicyData;
1200 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1201 ASSERT_EQ(DLP_OK, res);
1202 AccountType tempType;
1203 ASSERT_NE(encDataJson.find(ENC_ACCOUNT_TYPE), encDataJson.end());
1204 ASSERT_EQ(encDataJson.at(ENC_ACCOUNT_TYPE).is_number(), true);
1205 encDataJson.at(ENC_ACCOUNT_TYPE).get_to(tempType);
1206 decDataJson[ENC_ACCOUNT_TYPE] = "test";
1207 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1208 ASSERT_EQ(DLP_OK, res);
1209 decDataJson.erase(ENC_ACCOUNT_TYPE);
1210 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1211 ASSERT_EQ(DLP_OK, res);
1212 decDataJson[ENC_ACCOUNT_TYPE] = tempType;
1213 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyData(decDataJson, decPolicyData, false);
1214 ASSERT_EQ(DLP_OK, res);
1215 }
1216
1217 /**
1218 * @tc.name: UninstallDlpSandboxApp001
1219 * @tc.desc: UninstallDlpSandboxApp test
1220 * @tc.type: FUNC
1221 * @tc.require:
1222 */
1223 HWTEST_F(DlpPermissionServiceTest, UninstallDlpSandboxApp001, TestSize.Level1)
1224 {
1225 DLP_LOG_DEBUG(LABEL, "UninstallDlpSandboxApp001");
1226
1227 std::string bundleName;
1228 int32_t appIndex = 0;
1229 int32_t userId = 0;
1230 int32_t ret = dlpPermissionService_->UninstallDlpSandboxApp(bundleName, appIndex, userId);
1231 ASSERT_EQ(DLP_SERVICE_ERROR_UNINSTALL_SANDBOX_FAIL, ret);
1232 }
1233
1234 /**
1235 * @tc.name: GetSandboxExternalAuthorization001
1236 * @tc.desc: GetSandboxExternalAuthorization test
1237 * @tc.type: FUNC
1238 * @tc.require:
1239 */
1240 HWTEST_F(DlpPermissionServiceTest, GetSandboxExternalAuthorization001, TestSize.Level1)
1241 {
1242 DLP_LOG_DEBUG(LABEL, "GetSandboxExternalAuthorization001");
1243
1244 int sandboxUid = -1;
1245 AAFwk::Want want;
1246 SandBoxExternalAuthorType authType;
1247 int32_t ret = dlpPermissionService_->GetSandboxExternalAuthorization(sandboxUid, want, authType);
1248 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
1249 sandboxUid = 0;
1250 ret = dlpPermissionService_->GetSandboxExternalAuthorization(sandboxUid, want, authType);
1251 ASSERT_EQ(DLP_OK, ret);
1252 }
1253
1254 /**
1255 * @tc.name: GetSandboxExternalAuthorization002
1256 * @tc.desc: GetSandboxExternalAuthorization test
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 HWTEST_F(DlpPermissionServiceTest, GetSandboxExternalAuthorization002, TestSize.Level1)
1261 {
1262 DLP_LOG_DEBUG(LABEL, "GetSandboxExternalAuthorization002");
1263
1264 int sandboxUid = -1;
1265 AAFwk::Want want;
1266 SandBoxExternalAuthorType authType;
1267 DlpPermissionServiceTest::permType = -1;
1268 int32_t ret = dlpPermissionService_->GetSandboxExternalAuthorization(sandboxUid, want, authType);
1269 DlpPermissionServiceTest::permType = 0;
1270 EXPECT_NE(DLP_SERVICE_ERROR_MEMORY_OPERATE_FAIL, ret);
1271 }
1272
1273 /**
1274 * @tc.name: GetConfigFileValue001
1275 * @tc.desc: GetConfigFileValue test
1276 * @tc.type: FUNC
1277 * @tc.require:
1278 */
1279 HWTEST_F(DlpPermissionServiceTest, GetConfigFileValue001, TestSize.Level1)
1280 {
1281 DLP_LOG_DEBUG(LABEL, "GetConfigFileValue001");
1282
1283 std::string cfgFile;
1284 std::vector<std::string> typeList;
1285 (void)dlpPermissionService_->GetConfigFileValue(cfgFile, typeList);
1286 EXPECT_EQ(typeList.size(), 0);
1287 }
1288
1289 /**
1290 * @tc.name: RemoveRetentionInfo001
1291 * @tc.desc: RemoveRetentionInfo test
1292 * @tc.type: FUNC
1293 * @tc.require:
1294 */
1295 HWTEST_F(DlpPermissionServiceTest, RemoveRetentionInfo001, TestSize.Level1)
1296 {
1297 DLP_LOG_DEBUG(LABEL, "RemoveRetentionInfo001");
1298
1299 std::vector<RetentionSandBoxInfo> retentionSandBoxInfoVec;
1300 RetentionInfo info;
1301 bool ret = dlpPermissionService_->RemoveRetentionInfo(retentionSandBoxInfoVec, info);
1302 ASSERT_EQ(true, ret);
1303 }
1304
1305 /**
1306 * @tc.name: DeserializeEncPolicyDataByFirstVersion001
1307 * @tc.desc: DeserializeEncPolicyDataByFirstVersion test
1308 * @tc.type: FUNC
1309 * @tc.require:
1310 */
1311 HWTEST_F(DlpPermissionServiceTest, DeserializeEncPolicyDataByFirstVersion001, TestSize.Level1)
1312 {
1313 DLP_LOG_INFO(LABEL, "DeserializeEncPolicyDataByFirstVersion001");
1314 unordered_json encDataJson = {
1315 { ENC_DATA_LEN, 11 }
1316 };
1317 unordered_json encDataJson2;
1318 DLP_EncPolicyData encData;
1319 std::string ownerAccountId;
1320 int res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1321 encData, ownerAccountId);
1322 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1323 encDataJson[ENC_DATA] = "1";
1324 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1325 encData, ownerAccountId);
1326 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1327 encDataJson[EXTRA_INFO] = "1";
1328 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1329 encData, ownerAccountId);
1330 ASSERT_EQ(res, DLP_OK);
1331 encDataJson2[ENC_POLICY] = "1";
1332 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1333 encData, ownerAccountId);
1334 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1335 encDataJson2[ENC_ACCOUNT_TYPE] = 2;
1336 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1337 encData, ownerAccountId);
1338 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1339 encDataJson2[EXTRA_INFO] = "1";
1340 res = DlpPermissionSerializer::GetInstance().DeserializeEncPolicyDataByFirstVersion(encDataJson, encDataJson2,
1341 encData, ownerAccountId);
1342 ASSERT_EQ(res, DLP_OK);
1343 }
1344
1345 /**
1346 * @tc.name: SandboxConfigOperate001
1347 * @tc.desc: SandboxConfigOperate test
1348 * @tc.type: FUNC
1349 * @tc.require:
1350 */
1351 HWTEST_F(DlpPermissionServiceTest, SandboxConfigOperate001, TestSize.Level1)
1352 {
1353 DLP_LOG_DEBUG(LABEL, "SandboxConfigOperate001");
1354 std::string config;
1355 int32_t ret = dlpPermissionService_->SandboxConfigOperate(config, SandboxConfigOperationEnum::ADD);
1356 ASSERT_NE(DLP_OK, ret);
1357 }
1358
1359 /**
1360 * @tc.name: SetReadFlag001
1361 * @tc.desc: SetReadFlag test
1362 * @tc.type: FUNC
1363 * @tc.require:
1364 */
1365 HWTEST_F(DlpPermissionServiceTest, SetReadFlag001, TestSize.Level1)
1366 {
1367 DLP_LOG_DEBUG(LABEL, "SetReadFlag001");
1368 uint32_t uid = 0;
1369 int32_t ret = dlpPermissionService_->SetReadFlag(uid);
1370 ASSERT_EQ(DLP_OK, ret);
1371 }
1372
1373 /**
1374 * @tc.name: QueryDlpFileAccess001
1375 * @tc.desc: QueryDlpFileAccess test
1376 * @tc.type: FUNC
1377 * @tc.require:
1378 */
1379 HWTEST_F(DlpPermissionServiceTest, QueryDlpFileAccess001, TestSize.Level1)
1380 {
1381 DLPPermissionInfoParcel permInfoParcel;
1382 DlpPermissionServiceTest::isSandbox = false;
1383 int32_t res = dlpPermissionService_->QueryDlpFileAccess(permInfoParcel);
1384 DlpPermissionServiceTest::isSandbox = true;
1385 ASSERT_EQ(DLP_SERVICE_ERROR_API_ONLY_FOR_SANDBOX_ERROR, res);
1386
1387 DlpPermissionServiceTest::isCheckSandbox = false;
1388 res = dlpPermissionService_->QueryDlpFileAccess(permInfoParcel);
1389 DlpPermissionServiceTest::isCheckSandbox = true;
1390 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1391 }
1392
1393 /**
1394 * @tc.name: RegisterOpenDlpFileCallback001
1395 * @tc.desc: RegisterOpenDlpFileCallback test
1396 * @tc.type: FUNC
1397 * @tc.require:
1398 */
1399 HWTEST_F(DlpPermissionServiceTest, RegisterOpenDlpFileCallback001, TestSize.Level1)
1400 {
1401 DlpPermissionServiceTest::isSandbox = true;
1402 int32_t res = dlpPermissionService_->RegisterOpenDlpFileCallback(nullptr);
1403 ASSERT_EQ(DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR, res);
1404
1405 DlpPermissionServiceTest::isCheckSandbox = false;
1406 res = dlpPermissionService_->RegisterOpenDlpFileCallback(nullptr);
1407 DlpPermissionServiceTest::isCheckSandbox = true;
1408 ASSERT_EQ(res, DLP_SERVICE_ERROR_VALUE_INVALID);
1409 }
1410
1411
1412 /**
1413 * @tc.name: SetRetentionState001
1414 * @tc.desc: SetRetentionState test success
1415 * @tc.type: FUNC
1416 * @tc.require:issue：IAIFTY
1417 */
1418 HWTEST_F(DlpPermissionServiceTest, SetRetentionState001, TestSize.Level1)
1419 {
1420 DLP_LOG_DEBUG(LABEL, "SetRetentionState001");
1421
1422 std::vector<std::string> docUriVec;
1423 docUriVec.push_back("hh");
1424 int32_t uid = IPCSkeleton::GetCallingUid();
1425 int32_t userId;
1426 GetUserIdFromUid(uid, &userId);
1427 DlpSandboxInfo appInfo;
1428 appInfo = {
1429 .uid = uid,
1430 .userId = userId,
1431 .appIndex = 0,
1432 .bundleName = "testbundle1",
1433 .hasRead = false
1434 };
1435 dlpPermissionService_->appStateObserver_->AddSandboxInfo(appInfo);
1436 int32_t ret = dlpPermissionService_->SetRetentionState(docUriVec);
1437 ASSERT_EQ(ret, DLP_OK);
1438
1439 std::vector<RetentionSandBoxInfo> retentionSandBoxInfoVec;
1440 RetentionSandBoxInfo retentionSandBoxInfo;
1441 retentionSandBoxInfo.appIndex_ = appInfo.appIndex;
1442 retentionSandBoxInfoVec.push_back(retentionSandBoxInfo);
1443 RetentionSandBoxInfo retentionSandBoxInfo1;
1444 retentionSandBoxInfo1.appIndex_ = appInfo.appIndex + 1;
1445 retentionSandBoxInfoVec.push_back(retentionSandBoxInfo1);
1446
1447 RetentionInfo info;
1448 info.bundleName = appInfo.bundleName;
1449 bool res = dlpPermissionService_->RemoveRetentionInfo(retentionSandBoxInfoVec, info);
1450 ASSERT_TRUE(res);
1451 }
1452
1453 /**
1454 * @tc.name: SetRetentionState002
1455 * @tc.desc: SetRetentionState test
1456 * @tc.type: FUNC
1457 * @tc.require:
1458 */
1459 HWTEST_F(DlpPermissionServiceTest, SetRetentionState002, TestSize.Level1)
1460 {
1461 std::vector<std::string> docUriVec;
1462 docUriVec.push_back("hh");
1463 DlpPermissionServiceTest::isSandbox = false;
1464 int32_t ret = dlpPermissionService_->SetRetentionState(docUriVec);
1465 DlpPermissionServiceTest::isSandbox = true;
1466 ASSERT_EQ(ret, DLP_SERVICE_ERROR_API_ONLY_FOR_SANDBOX_ERROR);
1467
1468 DlpPermissionServiceTest::isCheckSandbox = false;
1469 ret = dlpPermissionService_->SetRetentionState(docUriVec);
1470 DlpPermissionServiceTest::isCheckSandbox = true;
1471 ASSERT_EQ(ret, DLP_SERVICE_ERROR_VALUE_INVALID);
1472
1473 docUriVec.clear();
1474 ret = dlpPermissionService_->SetRetentionState(docUriVec);
1475 ASSERT_EQ(ret, DLP_SERVICE_ERROR_VALUE_INVALID);
1476 }
1477
1478 /**
1479 * @tc.name: GetRetentionSandboxList001
1480 * @tc.desc: GetRetentionSandboxList test
1481 * @tc.type: FUNC
1482 * @tc.require:
1483 */
1484 HWTEST_F(DlpPermissionServiceTest, GetRetentionSandboxList001, TestSize.Level1)
1485 {
1486 std::vector<RetentionSandBoxInfo> vec;
1487 DlpPermissionServiceTest::isSandbox = true;
1488 int32_t ret = dlpPermissionService_->GetRetentionSandboxList("testbundle1", vec);
1489 ASSERT_EQ(ret, DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR);
1490
1491 DlpPermissionServiceTest::isCheckSandbox = false;
1492 ret = dlpPermissionService_->GetRetentionSandboxList("testbundle1", vec);
1493 DlpPermissionServiceTest::isCheckSandbox = true;
1494 ASSERT_EQ(ret, DLP_SERVICE_ERROR_VALUE_INVALID);
1495 }
1496
1497 /**
1498 * @tc.name: GetDLPFileVisitRecord001
1499 * @tc.desc: GetDLPFileVisitRecord test
1500 * @tc.type: FUNC
1501 * @tc.require:
1502 */
1503 HWTEST_F(DlpPermissionServiceTest, GetDLPFileVisitRecord001, TestSize.Level1)
1504 {
1505 std::vector<VisitedDLPFileInfo> infoVec;
1506
1507 DlpPermissionServiceTest::isSandbox = true;
1508 int32_t ret = dlpPermissionService_->GetDLPFileVisitRecord(infoVec);
1509 ASSERT_EQ(ret, DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR);
1510
1511 DlpPermissionServiceTest::isCheckSandbox = false;
1512 ret = dlpPermissionService_->GetDLPFileVisitRecord(infoVec);
1513 DlpPermissionServiceTest::isCheckSandbox = true;
1514 ASSERT_EQ(ret, DLP_SERVICE_ERROR_VALUE_INVALID);
1515 }
1516
1517 /**
1518 * @tc.name: CleanSandboxAppConfig001
1519 * @tc.desc: CleanSandboxAppConfig test
1520 * @tc.type: FUNC
1521 * @tc.require:
1522 */
1523 HWTEST_F(DlpPermissionServiceTest, CleanSandboxAppConfig001, TestSize.Level1)
1524 {
1525 DlpPermissionServiceTest::isSandbox = true;
1526 int32_t ret = dlpPermissionService_->CleanSandboxAppConfig();
1527 ASSERT_EQ(ret, DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR);
1528
1529 DlpPermissionServiceTest::isCheckSandbox = false;
1530 ret = dlpPermissionService_->CleanSandboxAppConfig();
1531 DlpPermissionServiceTest::isCheckSandbox = true;
1532 ASSERT_EQ(ret, DLP_SERVICE_ERROR_VALUE_INVALID);
1533 }
1534
1535 /**
1536 * @tc.name: SetDlpFeature001
1537 * @tc.desc: SetDlpFeature test
1538 * @tc.type: FUNC
1539 * @tc.require:
1540 */
1541 HWTEST_F(DlpPermissionServiceTest, SetDlpFeature001, TestSize.Level1)
1542 {
1543 uint32_t dlpFeatureInfo = 0;
1544 bool statusSetInfo;
1545 int32_t ret = dlpPermissionService_->SetDlpFeature(dlpFeatureInfo, statusSetInfo);
1546 ASSERT_TRUE(ret != DLP_CALLBACK_SA_WORK_ABNORMAL);
1547 }