1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "dlp_file_kits_test.h"
17 #include <cstdio>
18 #include <fcntl.h>
19 #include <fstream>
20 #include <iostream>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <vector>
24 #include "ability_info.h"
25 #include "accesstoken_kit.h"
26 #include "base_obj.h"
27 #include "dlp_file.h"
28 #include "dlp_file_kits.h"
29 #include "dlp_file_manager.h"
30 #include "dlp_permission.h"
31 #include "dlp_permission_log.h"
32 #include "dlp_utils.h"
33 #include "int_wrapper.h"
34 #include "permission_policy.h"
35 #include "string_wrapper.h"
36 #include "want_params_wrapper.h"
37
38 using namespace testing::ext;
39 using namespace OHOS::Security::DlpPermission;
40 using namespace OHOS::Security::AccessToken;
41 using namespace std;
42
43 using Want = OHOS::AAFwk::Want;
44 using WantParams = OHOS::AAFwk::WantParams;
45 using WantParamWrapper = OHOS::AAFwk::WantParamWrapper;
46 using String = OHOS::AAFwk::String;
47 using Integer = OHOS::AAFwk::Integer;
48 namespace OHOS {
49 namespace AppFileService {
50 namespace ModuleFileUri {
51 namespace {
52 static const std::string DLP_FILE_NAME = "/data/test/fuse_test.txt.dlp";
53 }
GetRealPath()54 std::string FileUri::GetRealPath()
55 {
56 static int32_t gCount = 1;
57 if (gCount == 1) {
58 gCount++;
59 return DLP_FILE_NAME;
60 }
61 return "";
62 }
63 }
64 }
65 }
66 namespace {
67 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpFileKitsTest"};
68
69 static int g_dlpFileFd = -1;
70 static const std::string PLAIN_FILE_NAME = "/data/test/fuse_test.txt";
71 static const std::string DLP_FILE_NAME = "/data/test/fuse_test.txt.dlp";
72 static const std::string DLP_FILE_NAME_2 = "/data/test/fuse_test2.txt.dlp";
73 static const std::string DLP_FILE_URI = "file://data/test/fuse_test.txt.dlp";
74 static const std::string DLP_FILE_URI_2 = "file://data/test/fuse_test2.txt.dlp";
75 static const std::string PLAIN_FILE_URI = "file://data/test/fuse_test.txt";
76 static const std::string DLP_FILE_ERR_SUFFIX_URI = "file://data/test/fuse_test..txt";
77 static const std::string DLP_FILE_ERR_SUFFIX_URI_2 = "file://data/test/fuse_test.aaa.txt";
78 static const std::string DLP_TEST_DIR = "/data/test/dlpTest/";
79 static const int DLP_FILE_PERMISSION = 0777;
80 static const int FIVE = 5;
81
CreateDlpFileFd()82 void CreateDlpFileFd()
83 {
84 int plainFileFd = open(PLAIN_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
85 if (plainFileFd < 0) {
86 cout << "create dlpFile fd failed" << endl;
87 return;
88 }
89 int fileFd = open(DLP_FILE_NAME_2.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
90 if (fileFd < 0) {
91 close(plainFileFd);
92 cout << "create dlpFile fd failed" << endl;
93 return;
94 }
95 g_dlpFileFd = open(DLP_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
96 if (g_dlpFileFd < 0) {
97 close(plainFileFd);
98 close(fileFd);
99 cout << "create dlpFile fd failed" << endl;
100 return;
101 }
102
103 struct DlpProperty prop;
104 prop.ownerAccount = "ohosAnonymousName";
105 prop.ownerAccountId = "ohosAnonymousName";
106 prop.ownerAccountType = CLOUD_ACCOUNT;
107 prop.contactAccount = "test@test.com";
108
109 std::shared_ptr<DlpFile> filePtr;
110 int ret = DlpFileManager::GetInstance().GenerateDlpFile(plainFileFd,
111 g_dlpFileFd, prop, filePtr, DLP_TEST_DIR);
112 close(plainFileFd);
113 close(fileFd);
114 if (ret != DLP_OK) {
115 cout << "create dlpFile object failed" << endl;
116 return;
117 }
118 DlpFileManager::GetInstance().CloseDlpFile(filePtr);
119 }
120 }
121
SetUpTestCase()122 void DlpFileKitsTest::SetUpTestCase()
123 {
124 struct stat fstat;
125 if (stat(DLP_TEST_DIR.c_str(), &fstat) != 0) {
126 if (errno == ENOENT) {
127 int32_t ret = mkdir(DLP_TEST_DIR.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
128 if (ret < 0) {
129 DLP_LOG_ERROR(LABEL, "mkdir mount point failed errno %{public}d", errno);
130 return;
131 }
132 } else {
133 DLP_LOG_ERROR(LABEL, "get mount point failed errno %{public}d", errno);
134 return;
135 }
136 }
137 CreateDlpFileFd();
138 }
139
TearDownTestCase()140 void DlpFileKitsTest::TearDownTestCase()
141 {
142 if (g_dlpFileFd != -1) {
143 close(g_dlpFileFd);
144 g_dlpFileFd = -1;
145 }
146 rmdir(DLP_TEST_DIR.c_str());
147 }
148
SetUp()149 void DlpFileKitsTest::SetUp() {}
150
TearDown()151 void DlpFileKitsTest::TearDown() {}
152
153 /**
154 * @tc.name: GetSandboxFlag001
155 * @tc.desc: Get Sandbox flag, want valid
156 * @tc.type: FUNC
157 * @tc.require:AR000H7BOC
158 */
159 HWTEST_F(DlpFileKitsTest, GetSandboxFlag001, TestSize.Level0)
160 {
161 DLP_LOG_INFO(LABEL, "GetSandboxFlag001");
162 OHOS::AAFwk::Want want;
163
164 want.SetAction(TAG_ACTION_VIEW);
165 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
166 want.SetAction(TAG_ACTION_EDIT);
167 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
168 }
169
170 /**
171 * @tc.name: GetSandboxFlag002
172 * @tc.desc: Get Sandbox flag, action inValid
173 * @tc.type: FUNC
174 * @tc.require:AR000H7BOC
175 */
176 HWTEST_F(DlpFileKitsTest, GetSandboxFlag002, TestSize.Level0)
177 {
178 DLP_LOG_INFO(LABEL, "GetSandboxFlag002");
179 OHOS::AAFwk::Want want;
180 want.SetAction("ohos.want.action.home");
181
182 WantParams TopParam;
183 WantParams fileNameParam;
184 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
185 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
186
187 WantParams fileFdParam;
188 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
189 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
190 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
191 want.SetParams(TopParam);
192
193 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
194 ASSERT_FALSE((want.GetType() == "text/plain"));
195 }
196
197 /**
198 * @tc.name: GetSandboxFlag003
199 * @tc.desc: Get Sandbox flag, no fileName param
200 * @tc.type: FUNC
201 * @tc.require:AR000H7BOC
202 */
203 HWTEST_F(DlpFileKitsTest, GetSandboxFlag003, TestSize.Level0)
204 {
205 DLP_LOG_INFO(LABEL, "GetSandboxFlag003");
206 OHOS::AAFwk::Want want;
207 want.SetAction(TAG_ACTION_VIEW);
208
209 WantParams TopParam;
210 WantParams fileFdParam;
211 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
212 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
213 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
214 want.SetParams(TopParam);
215
216 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
217 ASSERT_FALSE((want.GetType() == "text/plain"));
218 }
219
220 /**
221 * @tc.name: GetSandboxFlag004
222 * @tc.desc: Get Sandbox flag, file name is not dlp
223 * @tc.type: FUNC
224 * @tc.require:AR000H7BOC
225 */
226 HWTEST_F(DlpFileKitsTest, GetSandboxFlag004, TestSize.Level0)
227 {
228 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
229 OHOS::AAFwk::Want want;
230 want.SetAction(TAG_ACTION_VIEW);
231 want.SetUri(DLP_FILE_URI);
232
233 ASSERT_TRUE(DlpFileKits::GetSandboxFlag(want));
234 }
235
236 /**
237 * @tc.name: GetSandboxFlag005
238 * @tc.desc: Get Sandbox flag, file name is .dlp
239 * @tc.type: FUNC
240 * @tc.require:AR000H7BOC
241 */
242 HWTEST_F(DlpFileKitsTest, GetSandboxFlag005, TestSize.Level0)
243 {
244 DLP_LOG_INFO(LABEL, "GetSandboxFlag005");
245 OHOS::AAFwk::Want want;
246 want.SetAction(TAG_ACTION_VIEW);
247
248 WantParams TopParam;
249 WantParams fileNameParam;
250 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box(".dlp"));
251 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
252
253 WantParams fileFdParam;
254 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
255 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
256 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
257 want.SetParams(TopParam);
258
259 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
260 ASSERT_FALSE((want.GetType() == "text/plain"));
261 }
262
263 /**
264 * @tc.name: GetSandboxFlag006
265 * @tc.desc: Get Sandbox flag, file name is less than ".dlp"
266 * @tc.type: FUNC
267 * @tc.require:AR000H7BOC
268 */
269 HWTEST_F(DlpFileKitsTest, GetSandboxFlag006, TestSize.Level0)
270 {
271 DLP_LOG_INFO(LABEL, "GetSandboxFlag006");
272 OHOS::AAFwk::Want want;
273 want.SetAction(TAG_ACTION_VIEW);
274
275 WantParams TopParam;
276 WantParams fileNameParam;
277 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("lp"));
278 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
279
280 WantParams fileFdParam;
281 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
282 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
283 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
284 want.SetParams(TopParam);
285
286 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
287 ASSERT_FALSE((want.GetType() == "text/plain"));
288 }
289
290 /**
291 * @tc.name: GetSandboxFlag008
292 * @tc.desc: Get Sandbox flag, no keyFd
293 * @tc.type: FUNC
294 * @tc.require:AR000H7BOC
295 */
296 HWTEST_F(DlpFileKitsTest, GetSandboxFlag008, TestSize.Level0)
297 {
298 DLP_LOG_INFO(LABEL, "GetSandboxFlag008");
299 OHOS::AAFwk::Want want;
300 want.SetAction(TAG_ACTION_VIEW);
301
302 WantParams TopParam;
303 WantParams fileNameParam;
304 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
305 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
306 want.SetParams(TopParam);
307
308 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
309 ASSERT_FALSE((want.GetType() == "text/plain"));
310 }
311
312 /**
313 * @tc.name: GetSandboxFlag009
314 * @tc.desc: Get Sandbox flag, keyFd type is not FD
315 * @tc.type: FUNC
316 * @tc.require:AR000H7BOC
317 */
318 HWTEST_F(DlpFileKitsTest, GetSandboxFlag009, TestSize.Level0)
319 {
320 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
321 OHOS::AAFwk::Want want;
322 want.SetAction(TAG_ACTION_VIEW);
323
324 WantParams TopParam;
325 WantParams fileNameParam;
326 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
327 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
328
329 WantParams fileFdParam;
330 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box("FD1"));
331 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
332 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
333 want.SetParams(TopParam);
334
335 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
336 ASSERT_FALSE((want.GetType() == "text/plain"));
337 }
338
339 /**
340 * @tc.name: GetSandboxFlag010
341 * @tc.desc: Get Sandbox flag, fileFd has no value key
342 * @tc.type: FUNC
343 * @tc.require:AR000H7BOC
344 */
345 HWTEST_F(DlpFileKitsTest, GetSandboxFlag010, TestSize.Level0)
346 {
347 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
348 OHOS::AAFwk::Want want;
349 want.SetAction(TAG_ACTION_VIEW);
350
351 WantParams TopParam;
352 WantParams fileNameParam;
353 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
354 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
355
356 WantParams fileFdParam;
357 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
358 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
359 want.SetParams(TopParam);
360
361 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
362 ASSERT_FALSE((want.GetType() == "text/plain"));
363 }
364
365 /**
366 * @tc.name: GetSandboxFlag011
367 * @tc.desc: Get Sandbox flag, fileFd fd = -1
368 * @tc.type: FUNC
369 * @tc.require:AR000H7BOC
370 */
371 HWTEST_F(DlpFileKitsTest, GetSandboxFlag011, TestSize.Level0)
372 {
373 DLP_LOG_INFO(LABEL, "GetSandboxFlag011");
374 OHOS::AAFwk::Want want;
375 want.SetAction(TAG_ACTION_VIEW);
376
377 WantParams TopParam;
378 WantParams fileNameParam;
379 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
380 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
381
382 WantParams fileFdParam;
383 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
384 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(-1));
385 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
386 want.SetParams(TopParam);
387
388 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
389 ASSERT_FALSE((want.GetType() == "text/plain"));
390 }
391
392 /**
393 * @tc.name: GetSandboxFlag012
394 * @tc.desc: Get Sandbox flag, fileFd fd is real, but is not dlpfile fd
395 * @tc.type: FUNC
396 * @tc.require:AR000H7BOC
397 */
398 HWTEST_F(DlpFileKitsTest, GetSandboxFlag012, TestSize.Level0)
399 {
400 DLP_LOG_INFO(LABEL, "GetSandboxFlag012");
401 int plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
402 ASSERT_GE(plainFileFd, 0);
403
404 OHOS::AAFwk::Want want;
405 want.SetAction(TAG_ACTION_VIEW);
406
407 WantParams TopParam;
408 WantParams fileNameParam;
409 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
410 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
411
412 WantParams fileFdParam;
413 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
414 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(plainFileFd));
415 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
416 want.SetParams(TopParam);
417
418 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
419 ASSERT_FALSE((want.GetType() == "text/plain"));
420 }
421
422 /**
423 * @tc.name: GetSandboxFlag013
424 * @tc.desc: Get Sandbox flag, want valid
425 * @tc.type: FUNC
426 * @tc.require:AR000H7BOC
427 */
428 HWTEST_F(DlpFileKitsTest, GetSandboxFlag013, TestSize.Level0)
429 {
430 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
431 OHOS::AAFwk::Want want;
432 want.SetAction(TAG_ACTION_VIEW);
433 want.SetUri(PLAIN_FILE_URI);
434 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
435 want.SetUri(DLP_FILE_URI_2);
436 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
437 }
438
439 /**
440 * @tc.name: IsDlpFile001
441 * @tc.desc: test param whether dlpFd is valid.
442 * @tc.type: FUNC
443 * @tc.require:issue：IAIFTY
444 */
445 HWTEST_F(DlpFileKitsTest, IsDlpFile001, TestSize.Level0)
446 {
447 DLP_LOG_INFO(LABEL, "IsDlpFile001");
448
449 int32_t dlpFd = -1;
450 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
451
452 dlpFd = 1;
453 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
454
455 dlpFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
456 ASSERT_GE(dlpFd, 0);
457 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
458 ASSERT_EQ(close(dlpFd), 0);
459 }
460
461 /**
462 * @tc.name: ConvertAbilityInfoWithSupportDlp
463 * @tc.desc: test ConvertAbilityInfoWithSupportDlp param.
464 * @tc.type: FUNC
465 * @tc.require:issue：IAIFTY
466 */
467 HWTEST_F(DlpFileKitsTest, ConvertAbilityInfoWithSupportDlp001, TestSize.Level0)
468 {
469 DLP_LOG_INFO(LABEL, "ConvertAbilityInfoWithSupportDlp001");
470
471 OHOS::AAFwk::Want want;
472 std::vector<OHOS::AppExecFwk::AbilityInfo> abilityInfos;
473 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
474
475 std::vector<std::string> authPolicy;
476 std::string fileType = DlpUtils::GetFileTypeBySuffix("txt", true);
477 fileType = DlpUtils::GetFileTypeBySuffix("txt", false);
478 DlpUtils::GetAuthPolicyWithType(DLP_AUTH_POLICY, fileType, authPolicy);
479 OHOS::AppExecFwk::AbilityInfo abilityInfo;
480 for (const string& bundleName : authPolicy) {
481 abilityInfo.bundleName = bundleName;
482 abilityInfos.push_back(abilityInfo);
483 }
484
485 want.SetUri(PLAIN_FILE_URI);
486 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
487
488 want.SetUri(DLP_FILE_ERR_SUFFIX_URI);
489 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
490
491 want.SetUri(DLP_FILE_ERR_SUFFIX_URI_2);
492 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
493
494 want.SetUri(DLP_FILE_URI);
495 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
496 if (abilityInfos.size() == 0) {
497 EXPECT_EQ(abilityInfos.size(), 0);
498 } else {
499 EXPECT_EQ(abilityInfos.size(), FIVE);
500 }
501 }