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 "accesstoken_kit.h"
24 #include "dlp_file_kits.h"
25 #include "dlp_permission.h"
26 #include "dlp_permission_log.h"
27 #include "int_wrapper.h"
28 #include "string_wrapper.h"
29 #include "want_params_wrapper.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::Security::DlpPermission;
33 using namespace OHOS::Security::AccessToken;
34 using namespace std;
35
36 using Want = OHOS::AAFwk::Want;
37 using WantParams = OHOS::AAFwk::WantParams;
38 using WantParamWrapper = OHOS::AAFwk::WantParamWrapper;
39 using String = OHOS::AAFwk::String;
40 using Integer = OHOS::AAFwk::Integer;
41 namespace OHOS {
42 namespace AppFileService {
43 namespace ModuleFileUri {
44 namespace {
45 static const std::string DLP_FILE_NAME = "/data/test/fuse_test.txt.dlp";
46 }
GetRealPath()47 std::string FileUri::GetRealPath()
48 {
49 static int32_t gCount = 1;
50 if (gCount == 1) {
51 gCount++;
52 return DLP_FILE_NAME;
53 }
54 return "";
55 }
56 }
57 }
58 }
59 namespace {
60 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpFileKitsTest"};
61
62 static int g_dlpFileFd = -1;
63 static const std::string PLAIN_FILE_NAME = "/data/test/fuse_test.txt";
64 static const std::string DLP_FILE_NAME = "/data/test/fuse_test.txt.dlp";
65 static const std::string DLP_FILE_NAME_2 = "/data/test/fuse_test2.txt.dlp";
66 static const std::string DLP_FILE_URI = "file://data/test/fuse_test.txt.dlp";
67 static const std::string DLP_FILE_URI_2 = "file://data/test/fuse_test2.txt.dlp";
68 static const std::string PLAIN_FILE_URI = "file://data/test/fuse_test.txt";
69 static const std::string DLP_TEST_DIR = "/data/test/dlpTest/";
70 static const int DLP_FILE_PERMISSION = 0777;
71
CreateDlpFileFd()72 void CreateDlpFileFd()
73 {
74 int plainFileFd = open(PLAIN_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
75 if (plainFileFd < 0) {
76 cout << "create dlpFile fd failed" << endl;
77 return;
78 }
79 int fileFd = open(DLP_FILE_NAME_2.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
80 if (fileFd < 0) {
81 close(plainFileFd);
82 cout << "create dlpFile fd failed" << endl;
83 return;
84 }
85 g_dlpFileFd = open(DLP_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
86 if (g_dlpFileFd < 0) {
87 close(plainFileFd);
88 close(fileFd);
89 cout << "create dlpFile fd failed" << endl;
90 return;
91 }
92
93 struct DlpProperty prop;
94 prop.ownerAccount = "ohosAnonymousName";
95 prop.ownerAccountId = "ohosAnonymousName";
96 prop.ownerAccountType = CLOUD_ACCOUNT;
97 prop.contactAccount = "test@test.com";
98
99 std::shared_ptr<DlpFile> filePtr;
100 int ret = DlpFileManager::GetInstance().GenerateDlpFile(plainFileFd,
101 g_dlpFileFd, prop, filePtr, DLP_TEST_DIR);
102 close(plainFileFd);
103 close(fileFd);
104 if (ret != DLP_OK) {
105 cout << "create dlpFile object failed" << endl;
106 return;
107 }
108 DlpFileManager::GetInstance().CloseDlpFile(filePtr);
109 }
110 }
111
SetUpTestCase()112 void DlpFileKitsTest::SetUpTestCase()
113 {
114 struct stat fstat;
115 if (stat(DLP_TEST_DIR.c_str(), &fstat) != 0) {
116 if (errno == ENOENT) {
117 int32_t ret = mkdir(DLP_TEST_DIR.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
118 if (ret < 0) {
119 DLP_LOG_ERROR(LABEL, "mkdir mount point failed errno %{public}d", errno);
120 return;
121 }
122 } else {
123 DLP_LOG_ERROR(LABEL, "get mount point failed errno %{public}d", errno);
124 return;
125 }
126 }
127 CreateDlpFileFd();
128 }
129
TearDownTestCase()130 void DlpFileKitsTest::TearDownTestCase()
131 {
132 if (g_dlpFileFd != -1) {
133 close(g_dlpFileFd);
134 g_dlpFileFd = -1;
135 }
136 rmdir(DLP_TEST_DIR.c_str());
137 }
138
SetUp()139 void DlpFileKitsTest::SetUp() {}
140
TearDown()141 void DlpFileKitsTest::TearDown() {}
142
143 /**
144 * @tc.name: GetSandboxFlag001
145 * @tc.desc: Get Sandbox flag, want valid
146 * @tc.type: FUNC
147 * @tc.require:AR000H7BOC
148 */
149 HWTEST_F(DlpFileKitsTest, GetSandboxFlag001, TestSize.Level1)
150 {
151 DLP_LOG_INFO(LABEL, "GetSandboxFlag001");
152 OHOS::AAFwk::Want want;
153
154 want.SetAction(TAG_ACTION_VIEW);
155 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
156 want.SetAction(TAG_ACTION_EDIT);
157 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
158 }
159
160 /**
161 * @tc.name: GetSandboxFlag002
162 * @tc.desc: Get Sandbox flag, action inValid
163 * @tc.type: FUNC
164 * @tc.require:AR000H7BOC
165 */
166 HWTEST_F(DlpFileKitsTest, GetSandboxFlag002, TestSize.Level1)
167 {
168 DLP_LOG_INFO(LABEL, "GetSandboxFlag002");
169 OHOS::AAFwk::Want want;
170 want.SetAction("ohos.want.action.home");
171
172 WantParams TopParam;
173 WantParams fileNameParam;
174 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
175 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
176
177 WantParams fileFdParam;
178 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
179 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
180 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
181 want.SetParams(TopParam);
182
183 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
184 ASSERT_FALSE((want.GetType() == "text/plain"));
185 }
186
187 /**
188 * @tc.name: GetSandboxFlag003
189 * @tc.desc: Get Sandbox flag, no fileName param
190 * @tc.type: FUNC
191 * @tc.require:AR000H7BOC
192 */
193 HWTEST_F(DlpFileKitsTest, GetSandboxFlag003, TestSize.Level1)
194 {
195 DLP_LOG_INFO(LABEL, "GetSandboxFlag003");
196 OHOS::AAFwk::Want want;
197 want.SetAction(TAG_ACTION_VIEW);
198
199 WantParams TopParam;
200 WantParams fileFdParam;
201 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
202 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
203 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
204 want.SetParams(TopParam);
205
206 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
207 ASSERT_FALSE((want.GetType() == "text/plain"));
208 }
209
210 /**
211 * @tc.name: GetSandboxFlag004
212 * @tc.desc: Get Sandbox flag, file name is not dlp
213 * @tc.type: FUNC
214 * @tc.require:AR000H7BOC
215 */
216 HWTEST_F(DlpFileKitsTest, GetSandboxFlag004, TestSize.Level1)
217 {
218 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
219 OHOS::AAFwk::Want want;
220 want.SetAction(TAG_ACTION_VIEW);
221 want.SetUri(DLP_FILE_URI);
222
223 ASSERT_TRUE(DlpFileKits::GetSandboxFlag(want));
224 }
225
226 /**
227 * @tc.name: GetSandboxFlag005
228 * @tc.desc: Get Sandbox flag, file name is .dlp
229 * @tc.type: FUNC
230 * @tc.require:AR000H7BOC
231 */
232 HWTEST_F(DlpFileKitsTest, GetSandboxFlag005, TestSize.Level1)
233 {
234 DLP_LOG_INFO(LABEL, "GetSandboxFlag005");
235 OHOS::AAFwk::Want want;
236 want.SetAction(TAG_ACTION_VIEW);
237
238 WantParams TopParam;
239 WantParams fileNameParam;
240 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box(".dlp"));
241 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
242
243 WantParams fileFdParam;
244 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
245 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
246 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
247 want.SetParams(TopParam);
248
249 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
250 ASSERT_FALSE((want.GetType() == "text/plain"));
251 }
252
253 /**
254 * @tc.name: GetSandboxFlag006
255 * @tc.desc: Get Sandbox flag, file name is less than ".dlp"
256 * @tc.type: FUNC
257 * @tc.require:AR000H7BOC
258 */
259 HWTEST_F(DlpFileKitsTest, GetSandboxFlag006, TestSize.Level1)
260 {
261 DLP_LOG_INFO(LABEL, "GetSandboxFlag006");
262 OHOS::AAFwk::Want want;
263 want.SetAction(TAG_ACTION_VIEW);
264
265 WantParams TopParam;
266 WantParams fileNameParam;
267 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("lp"));
268 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
269
270 WantParams fileFdParam;
271 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
272 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
273 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
274 want.SetParams(TopParam);
275
276 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
277 ASSERT_FALSE((want.GetType() == "text/plain"));
278 }
279
280 /**
281 * @tc.name: GetSandboxFlag008
282 * @tc.desc: Get Sandbox flag, no keyFd
283 * @tc.type: FUNC
284 * @tc.require:AR000H7BOC
285 */
286 HWTEST_F(DlpFileKitsTest, GetSandboxFlag008, TestSize.Level1)
287 {
288 DLP_LOG_INFO(LABEL, "GetSandboxFlag008");
289 OHOS::AAFwk::Want want;
290 want.SetAction(TAG_ACTION_VIEW);
291
292 WantParams TopParam;
293 WantParams fileNameParam;
294 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
295 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
296 want.SetParams(TopParam);
297
298 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
299 ASSERT_FALSE((want.GetType() == "text/plain"));
300 }
301
302 /**
303 * @tc.name: GetSandboxFlag009
304 * @tc.desc: Get Sandbox flag, keyFd type is not FD
305 * @tc.type: FUNC
306 * @tc.require:AR000H7BOC
307 */
308 HWTEST_F(DlpFileKitsTest, GetSandboxFlag009, TestSize.Level1)
309 {
310 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
311 OHOS::AAFwk::Want want;
312 want.SetAction(TAG_ACTION_VIEW);
313
314 WantParams TopParam;
315 WantParams fileNameParam;
316 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
317 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
318
319 WantParams fileFdParam;
320 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box("FD1"));
321 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
322 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
323 want.SetParams(TopParam);
324
325 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
326 ASSERT_FALSE((want.GetType() == "text/plain"));
327 }
328
329 /**
330 * @tc.name: GetSandboxFlag010
331 * @tc.desc: Get Sandbox flag, fileFd has no value key
332 * @tc.type: FUNC
333 * @tc.require:AR000H7BOC
334 */
335 HWTEST_F(DlpFileKitsTest, GetSandboxFlag010, TestSize.Level1)
336 {
337 DLP_LOG_INFO(LABEL, "GetSandboxFlag009");
338 OHOS::AAFwk::Want want;
339 want.SetAction(TAG_ACTION_VIEW);
340
341 WantParams TopParam;
342 WantParams fileNameParam;
343 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
344 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
345
346 WantParams fileFdParam;
347 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
348 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
349 want.SetParams(TopParam);
350
351 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
352 ASSERT_FALSE((want.GetType() == "text/plain"));
353 }
354
355 /**
356 * @tc.name: GetSandboxFlag011
357 * @tc.desc: Get Sandbox flag, fileFd fd = -1
358 * @tc.type: FUNC
359 * @tc.require:AR000H7BOC
360 */
361 HWTEST_F(DlpFileKitsTest, GetSandboxFlag011, TestSize.Level1)
362 {
363 DLP_LOG_INFO(LABEL, "GetSandboxFlag011");
364 OHOS::AAFwk::Want want;
365 want.SetAction(TAG_ACTION_VIEW);
366
367 WantParams TopParam;
368 WantParams fileNameParam;
369 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
370 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
371
372 WantParams fileFdParam;
373 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
374 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(-1));
375 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
376 want.SetParams(TopParam);
377
378 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
379 ASSERT_FALSE((want.GetType() == "text/plain"));
380 }
381
382 /**
383 * @tc.name: GetSandboxFlag012
384 * @tc.desc: Get Sandbox flag, fileFd fd is real, but is not dlpfile fd
385 * @tc.type: FUNC
386 * @tc.require:AR000H7BOC
387 */
388 HWTEST_F(DlpFileKitsTest, GetSandboxFlag012, TestSize.Level1)
389 {
390 DLP_LOG_INFO(LABEL, "GetSandboxFlag012");
391 int plainFileFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
392 ASSERT_GE(plainFileFd, 0);
393
394 OHOS::AAFwk::Want want;
395 want.SetAction(TAG_ACTION_VIEW);
396
397 WantParams TopParam;
398 WantParams fileNameParam;
399 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
400 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
401
402 WantParams fileFdParam;
403 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
404 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(plainFileFd));
405 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
406 want.SetParams(TopParam);
407
408 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
409 ASSERT_FALSE((want.GetType() == "text/plain"));
410 }
411
412 /**
413 * @tc.name: GetSandboxFlag013
414 * @tc.desc: Get Sandbox flag, want valid
415 * @tc.type: FUNC
416 * @tc.require:AR000H7BOC
417 */
418 HWTEST_F(DlpFileKitsTest, GetSandboxFlag013, TestSize.Level1)
419 {
420 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
421 OHOS::AAFwk::Want want;
422 want.SetAction(TAG_ACTION_VIEW);
423 want.SetUri(PLAIN_FILE_URI);
424 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
425 want.SetUri(DLP_FILE_URI_2);
426 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
427 }
428
429 /**
430 * @tc.name: IsDlpFile001
431 * @tc.desc: test param whether dlpFd is valid.
432 * @tc.type: FUNC
433 * @tc.require:issue：IAIFTY
434 */
435 HWTEST_F(DlpFileKitsTest, IsDlpFile001, TestSize.Level1)
436 {
437 DLP_LOG_INFO(LABEL, "IsDlpFile001");
438
439 int32_t dlpFd = -1;
440 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
441
442 dlpFd = 1;
443 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
444
445 dlpFd = open("/data/fuse_test.txt", O_CREAT | O_RDWR | O_TRUNC, 0777);
446 ASSERT_GE(dlpFd, 0);
447 ASSERT_FALSE(DlpFileKits::IsDlpFile(dlpFd));
448 ASSERT_EQ(close(dlpFd), 0);
449 }