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
CreateDlpFileFd()81 void CreateDlpFileFd()
82 {
83 int plainFileFd = open(PLAIN_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
84 if (plainFileFd < 0) {
85 cout << "create dlpFile fd failed" << endl;
86 return;
87 }
88 int fileFd = open(DLP_FILE_NAME_2.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
89 if (fileFd < 0) {
90 close(plainFileFd);
91 cout << "create dlpFile fd failed" << endl;
92 return;
93 }
94 g_dlpFileFd = open(DLP_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
95 if (g_dlpFileFd < 0) {
96 close(plainFileFd);
97 close(fileFd);
98 cout << "create dlpFile fd failed" << endl;
99 return;
100 }
101
102 struct DlpProperty prop;
103 prop.ownerAccount = "ohosAnonymousName";
104 prop.ownerAccountId = "ohosAnonymousName";
105 prop.ownerAccountType = CLOUD_ACCOUNT;
106 prop.contactAccount = "test@test.com";
107
108 std::shared_ptr<DlpFile> filePtr;
109 int ret = DlpFileManager::GetInstance().GenerateDlpFile(plainFileFd,
110 g_dlpFileFd, prop, filePtr, DLP_TEST_DIR);
111 close(plainFileFd);
112 close(fileFd);
113 if (ret != DLP_OK) {
114 cout << "create dlpFile object failed" << endl;
115 return;
116 }
117 DlpFileManager::GetInstance().CloseDlpFile(filePtr);
118 }
119 }
120
SetUpTestCase()121 void DlpFileKitsTest::SetUpTestCase()
122 {
123 struct stat fstat;
124 if (stat(DLP_TEST_DIR.c_str(), &fstat) != 0) {
125 if (errno == ENOENT) {
126 int32_t ret = mkdir(DLP_TEST_DIR.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
127 if (ret < 0) {
128 DLP_LOG_ERROR(LABEL, "mkdir mount point failed errno %{public}d", errno);
129 return;
130 }
131 } else {
132 DLP_LOG_ERROR(LABEL, "get mount point failed errno %{public}d", errno);
133 return;
134 }
135 }
136 CreateDlpFileFd();
137 }
138
TearDownTestCase()139 void DlpFileKitsTest::TearDownTestCase()
140 {
141 if (g_dlpFileFd != -1) {
142 close(g_dlpFileFd);
143 g_dlpFileFd = -1;
144 }
145 rmdir(DLP_TEST_DIR.c_str());
146 }
147
SetUp()148 void DlpFileKitsTest::SetUp() {}
149
TearDown()150 void DlpFileKitsTest::TearDown() {}
151
152 /**
153 * @tc.name: GetSandboxFlag001
154 * @tc.desc: Get Sandbox flag, want valid
155 * @tc.type: FUNC
156 * @tc.require:AR000H7BOC
157 */
158 HWTEST_F(DlpFileKitsTest, GetSandboxFlag001, TestSize.Level1)
159 {
160 DLP_LOG_INFO(LABEL, "GetSandboxFlag001");
161 OHOS::AAFwk::Want want;
162
163 want.SetAction(TAG_ACTION_VIEW);
164 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
165 want.SetAction(TAG_ACTION_EDIT);
166 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
167 }
168
169 /**
170 * @tc.name: GetSandboxFlag002
171 * @tc.desc: Get Sandbox flag, action inValid
172 * @tc.type: FUNC
173 * @tc.require:AR000H7BOC
174 */
175 HWTEST_F(DlpFileKitsTest, GetSandboxFlag002, TestSize.Level1)
176 {
177 DLP_LOG_INFO(LABEL, "GetSandboxFlag002");
178 OHOS::AAFwk::Want want;
179 want.SetAction("ohos.want.action.home");
180
181 WantParams TopParam;
182 WantParams fileNameParam;
183 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
184 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
185
186 WantParams fileFdParam;
187 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
188 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
189 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
190 want.SetParams(TopParam);
191
192 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
193 ASSERT_FALSE((want.GetType() == "text/plain"));
194 }
195
196 /**
197 * @tc.name: GetSandboxFlag003
198 * @tc.desc: Get Sandbox flag, no fileName param
199 * @tc.type: FUNC
200 * @tc.require:AR000H7BOC
201 */
202 HWTEST_F(DlpFileKitsTest, GetSandboxFlag003, TestSize.Level1)
203 {
204 DLP_LOG_INFO(LABEL, "GetSandboxFlag003");
205 OHOS::AAFwk::Want want;
206 want.SetAction(TAG_ACTION_VIEW);
207
208 WantParams TopParam;
209 WantParams fileFdParam;
210 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
211 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
212 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
213 want.SetParams(TopParam);
214
215 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
216 ASSERT_FALSE((want.GetType() == "text/plain"));
217 }
218
219 /**
220 * @tc.name: GetSandboxFlag004
221 * @tc.desc: Get Sandbox flag, file name is not dlp
222 * @tc.type: FUNC
223 * @tc.require:AR000H7BOC
224 */
225 HWTEST_F(DlpFileKitsTest, GetSandboxFlag004, TestSize.Level1)
226 {
227 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
228 OHOS::AAFwk::Want want;
229 want.SetAction(TAG_ACTION_VIEW);
230 want.SetUri(DLP_FILE_URI);
231
232 ASSERT_TRUE(DlpFileKits::GetSandboxFlag(want));
233 }
234
235 /**
236 * @tc.name: GetSandboxFlag005
237 * @tc.desc: Get Sandbox flag, file name is .dlp
238 * @tc.type: FUNC
239 * @tc.require:AR000H7BOC
240 */
241 HWTEST_F(DlpFileKitsTest, GetSandboxFlag005, TestSize.Level1)
242 {
243 DLP_LOG_INFO(LABEL, "GetSandboxFlag005");
244 OHOS::AAFwk::Want want;
245 want.SetAction(TAG_ACTION_VIEW);
246
247 WantParams TopParam;
248 WantParams fileNameParam;
249 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box(".dlp"));
250 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
251
252 WantParams fileFdParam;
253 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
254 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
255 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
256 want.SetParams(TopParam);
257
258 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
259 ASSERT_FALSE((want.GetType() == "text/plain"));
260 }
261
262 /**
263 * @tc.name: GetSandboxFlag006
264 * @tc.desc: Get Sandbox flag, file name is less than ".dlp"
265 * @tc.type: FUNC
266 * @tc.require:AR000H7BOC
267 */
268 HWTEST_F(DlpFileKitsTest, GetSandboxFlag006, TestSize.Level1)
269 {
270 DLP_LOG_INFO(LABEL, "GetSandboxFlag006");
271 OHOS::AAFwk::Want want;
272 want.SetAction(TAG_ACTION_VIEW);
273
274 WantParams TopParam;
275 WantParams fileNameParam;
276 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("lp"));
277 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
278
279 WantParams fileFdParam;
280 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
281 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
282 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
283 want.SetParams(TopParam);
284
285 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
286 ASSERT_FALSE((want.GetType() == "text/plain"));
287 }
288
289 /**
290 * @tc.name: GetSandboxFlag008
291 * @tc.desc: Get Sandbox flag, no keyFd
292 * @tc.type: FUNC
293 * @tc.require:AR000H7BOC
294 */
295 HWTEST_F(DlpFileKitsTest, GetSandboxFlag008, TestSize.Level1)
296 {
297 DLP_LOG_INFO(LABEL, "GetSandboxFlag008");
298 OHOS::AAFwk::Want want;
299 want.SetAction(TAG_ACTION_VIEW);
300
301 WantParams TopParam;
302 WantParams fileNameParam;
303 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
304 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
305 want.SetParams(TopParam);
306
307 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
308 ASSERT_FALSE((want.GetType() == "text/plain"));
309 }
310
311 /**
312 * @tc.name: GetSandboxFlag009
313 * @tc.desc: Get Sandbox flag, keyFd type is not FD
314 * @tc.type: FUNC
315 * @tc.require:AR000H7BOC
316 */
317 HWTEST_F(DlpFileKitsTest, GetSandboxFlag009, TestSize.Level1)
318 {
319 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
320 OHOS::AAFwk::Want want;
321 want.SetAction(TAG_ACTION_VIEW);
322
323 WantParams TopParam;
324 WantParams fileNameParam;
325 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
326 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
327
328 WantParams fileFdParam;
329 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box("FD1"));
330 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
331 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
332 want.SetParams(TopParam);
333
334 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
335 ASSERT_FALSE((want.GetType() == "text/plain"));
336 }
337
338 /**
339 * @tc.name: GetSandboxFlag010
340 * @tc.desc: Get Sandbox flag, fileFd has no value key
341 * @tc.type: FUNC
342 * @tc.require:AR000H7BOC
343 */
344 HWTEST_F(DlpFileKitsTest, GetSandboxFlag010, TestSize.Level1)
345 {
346 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
347 OHOS::AAFwk::Want want;
348 want.SetAction(TAG_ACTION_VIEW);
349
350 WantParams TopParam;
351 WantParams fileNameParam;
352 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
353 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
354
355 WantParams fileFdParam;
356 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
357 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
358 want.SetParams(TopParam);
359
360 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
361 ASSERT_FALSE((want.GetType() == "text/plain"));
362 }
363
364 /**
365 * @tc.name: GetSandboxFlag011
366 * @tc.desc: Get Sandbox flag, fileFd fd = -1
367 * @tc.type: FUNC
368 * @tc.require:AR000H7BOC
369 */
370 HWTEST_F(DlpFileKitsTest, GetSandboxFlag011, TestSize.Level1)
371 {
372 DLP_LOG_INFO(LABEL, "GetSandboxFlag011");
373 OHOS::AAFwk::Want want;
374 want.SetAction(TAG_ACTION_VIEW);
375
376 WantParams TopParam;
377 WantParams fileNameParam;
378 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
379 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
380
381 WantParams fileFdParam;
382 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
383 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(-1));
384 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
385 want.SetParams(TopParam);
386
387 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
388 ASSERT_FALSE((want.GetType() == "text/plain"));
389 }
390
391 /**
392 * @tc.name: GetSandboxFlag012
393 * @tc.desc: Get Sandbox flag, fileFd fd is real, but is not dlpfile fd
394 * @tc.type: FUNC
395 * @tc.require:AR000H7BOC
396 */
397 HWTEST_F(DlpFileKitsTest, GetSandboxFlag012, TestSize.Level1)
398 {
399 DLP_LOG_INFO(LABEL, "GetSandboxFlag012");
400 int plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
401 ASSERT_GE(plainFileFd, 0);
402
403 OHOS::AAFwk::Want want;
404 want.SetAction(TAG_ACTION_VIEW);
405
406 WantParams TopParam;
407 WantParams fileNameParam;
408 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
409 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
410
411 WantParams fileFdParam;
412 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
413 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(plainFileFd));
414 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
415 want.SetParams(TopParam);
416
417 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
418 ASSERT_FALSE((want.GetType() == "text/plain"));
419 }
420
421 /**
422 * @tc.name: GetSandboxFlag013
423 * @tc.desc: Get Sandbox flag, want valid
424 * @tc.type: FUNC
425 * @tc.require:AR000H7BOC
426 */
427 HWTEST_F(DlpFileKitsTest, GetSandboxFlag013, TestSize.Level1)
428 {
429 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
430 OHOS::AAFwk::Want want;
431 want.SetAction(TAG_ACTION_VIEW);
432 want.SetUri(PLAIN_FILE_URI);
433 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
434 want.SetUri(DLP_FILE_URI_2);
435 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
436 }
437
438 /**
439 * @tc.name: IsDlpFile001
440 * @tc.desc: test param whether dlpFd is valid.
441 * @tc.type: FUNC
442 * @tc.require:issue：IAIFTY
443 */
444 HWTEST_F(DlpFileKitsTest, IsDlpFile001, TestSize.Level1)
445 {
446 DLP_LOG_INFO(LABEL, "IsDlpFile001");
447
448 int32_t dlpFd = -1;
449 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
450
451 dlpFd = 1;
452 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
453
454 dlpFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
455 ASSERT_GE(dlpFd, 0);
456 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
457 ASSERT_EQ(close(dlpFd), 0);
458 }
459
460 /**
461 * @tc.name: ConvertAbilityInfoWithSupportDlp
462 * @tc.desc: test ConvertAbilityInfoWithSupportDlp param.
463 * @tc.type: FUNC
464 * @tc.require:issue：IAIFTY
465 */
466 HWTEST_F(DlpFileKitsTest, ConvertAbilityInfoWithSupportDlp001, TestSize.Level1)
467 {
468 DLP_LOG_INFO(LABEL, "ConvertAbilityInfoWithSupportDlp001");
469
470 OHOS::AAFwk::Want want;
471 std::vector<OHOS::AppExecFwk::AbilityInfo> abilityInfos;
472 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
473
474 std::vector<std::string> authPolicy;
475 std::string fileType = DlpUtils::GetFileTypeBySuffix("txt");
476 DlpUtils::GetAuthPolicyWithType(DLP_AUTH_POLICY, fileType, authPolicy);
477 OHOS::AppExecFwk::AbilityInfo abilityInfo;
478 for (const string& bundleName : authPolicy) {
479 abilityInfo.bundleName = bundleName;
480 abilityInfos.push_back(abilityInfo);
481 }
482
483 want.SetUri(PLAIN_FILE_URI);
484 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
485
486 want.SetUri(DLP_FILE_ERR_SUFFIX_URI);
487 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
488
489 want.SetUri(DLP_FILE_ERR_SUFFIX_URI_2);
490 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
491
492 want.SetUri(DLP_FILE_URI);
493 DlpFileKits::ConvertAbilityInfoWithSupportDlp(want, abilityInfos);
494 }