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