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 int DLP_FILE_PERMISSION = 0777;
50
CreateDlpFileFd()51 void CreateDlpFileFd()
52 {
53 int plainFileFd = open(PLAIN_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
54 g_dlpFileFd = open(DLP_FILE_NAME.c_str(), O_CREAT | O_RDWR | O_TRUNC, DLP_FILE_PERMISSION);
55 if (plainFileFd < 0 || g_dlpFileFd < 0) {
56 cout << "create dlpFile fd failed" << endl;
57 return;
58 }
59
60 struct DlpProperty prop;
61 prop.ownerAccount = "ohosAnonymousName";
62 prop.ownerAccountId = "ohosAnonymousName";
63 prop.ownerAccountType = CLOUD_ACCOUNT;
64 prop.contactAccount = "test@test.com";
65
66 std::shared_ptr<DlpFile> filePtr;
67 int ret = DlpFileManager::GetInstance().GenerateDlpFile(plainFileFd, g_dlpFileFd, prop, filePtr);
68 close(plainFileFd);
69 if (ret != DLP_OK) {
70 cout << "create dlpFile object failed" << endl;
71 return;
72 }
73 DlpFileManager::GetInstance().CloseDlpFile(filePtr);
74 }
75 }
76
SetUpTestCase()77 void DlpFileKitsTest::SetUpTestCase()
78 {
79 CreateDlpFileFd();
80 }
81
TearDownTestCase()82 void DlpFileKitsTest::TearDownTestCase()
83 {
84 if (g_dlpFileFd != -1) {
85 close(g_dlpFileFd);
86 g_dlpFileFd = -1;
87 }
88 }
89
SetUp()90 void DlpFileKitsTest::SetUp() {}
91
TearDown()92 void DlpFileKitsTest::TearDown() {}
93
94 /**
95 * @tc.name: GetSandboxFlag001
96 * @tc.desc: Get Sandbox flag, want valid
97 * @tc.type: FUNC
98 * @tc.require:AR000H7BOC
99 */
100 HWTEST_F(DlpFileKitsTest, GetSandboxFlag001, TestSize.Level1)
101 {
102 DLP_LOG_INFO(LABEL, "GetSandboxFlag001");
103 OHOS::AAFwk::Want want;
104
105 want.SetAction(TAG_ACTION_VIEW);
106
107 WantParams TopParam;
108 WantParams fileNameParam;
109 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
110 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
111
112 WantParams fileFdParam;
113 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
114 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
115 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
116 want.SetParams(TopParam);
117
118 ASSERT_TRUE(DlpFileKits::GetSandboxFlag(want));
119 ASSERT_TRUE((want.GetType() == "text/plain"));
120 }
121
122 /**
123 * @tc.name: GetSandboxFlag002
124 * @tc.desc: Get Sandbox flag, action inValid
125 * @tc.type: FUNC
126 * @tc.require:AR000H7BOC
127 */
128 HWTEST_F(DlpFileKitsTest, GetSandboxFlag002, TestSize.Level1)
129 {
130 DLP_LOG_INFO(LABEL, "GetSandboxFlag002");
131 OHOS::AAFwk::Want want;
132 want.SetAction("ohos.want.action.home");
133
134 WantParams TopParam;
135 WantParams fileNameParam;
136 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt.dlp"));
137 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
138
139 WantParams fileFdParam;
140 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
141 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
142 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
143 want.SetParams(TopParam);
144
145 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
146 ASSERT_FALSE((want.GetType() == "text/plain"));
147 }
148
149 /**
150 * @tc.name: GetSandboxFlag003
151 * @tc.desc: Get Sandbox flag, no fileName param
152 * @tc.type: FUNC
153 * @tc.require:AR000H7BOC
154 */
155 HWTEST_F(DlpFileKitsTest, GetSandboxFlag003, TestSize.Level1)
156 {
157 DLP_LOG_INFO(LABEL, "GetSandboxFlag003");
158 OHOS::AAFwk::Want want;
159 want.SetAction(TAG_ACTION_VIEW);
160
161 WantParams TopParam;
162 WantParams fileFdParam;
163 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
164 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
165 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
166 want.SetParams(TopParam);
167
168 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
169 ASSERT_FALSE((want.GetType() == "text/plain"));
170 }
171
172 /**
173 * @tc.name: GetSandboxFlag004
174 * @tc.desc: Get Sandbox flag, file name is not dlp
175 * @tc.type: FUNC
176 * @tc.require:AR000H7BOC
177 */
178 HWTEST_F(DlpFileKitsTest, GetSandboxFlag004, TestSize.Level1)
179 {
180 DLP_LOG_INFO(LABEL, "GetSandboxFlag004");
181 OHOS::AAFwk::Want want;
182 want.SetAction(TAG_ACTION_VIEW);
183
184 WantParams TopParam;
185 WantParams fileNameParam;
186 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.txt"));
187 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
188
189 WantParams fileFdParam;
190 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
191 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
192 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
193 want.SetParams(TopParam);
194
195 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
196 ASSERT_FALSE((want.GetType() == "text/plain"));
197 }
198
199 /**
200 * @tc.name: GetSandboxFlag005
201 * @tc.desc: Get Sandbox flag, file name is .dlp
202 * @tc.type: FUNC
203 * @tc.require:AR000H7BOC
204 */
205 HWTEST_F(DlpFileKitsTest, GetSandboxFlag005, TestSize.Level1)
206 {
207 DLP_LOG_INFO(LABEL, "GetSandboxFlag005");
208 OHOS::AAFwk::Want want;
209 want.SetAction(TAG_ACTION_VIEW);
210
211 WantParams TopParam;
212 WantParams fileNameParam;
213 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box(".dlp"));
214 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
215
216 WantParams fileFdParam;
217 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
218 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
219 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
220 want.SetParams(TopParam);
221
222 ASSERT_FALSE(DlpFileKits::GetSandboxFlag(want));
223 ASSERT_FALSE((want.GetType() == "text/plain"));
224 }
225
226 /**
227 * @tc.name: GetSandboxFlag006
228 * @tc.desc: Get Sandbox flag, file name is less than ".dlp"
229 * @tc.type: FUNC
230 * @tc.require:AR000H7BOC
231 */
232 HWTEST_F(DlpFileKitsTest, GetSandboxFlag006, TestSize.Level1)
233 {
234 DLP_LOG_INFO(LABEL, "GetSandboxFlag006");
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("lp"));
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: GetSandboxFlag007
255 * @tc.desc: Get Sandbox flag, file name has not origin suffix
256 * @tc.type: FUNC
257 * @tc.require:AR000H7BOC
258 */
259 HWTEST_F(DlpFileKitsTest, GetSandboxFlag007, TestSize.Level1)
260 {
261 DLP_LOG_INFO(LABEL, "GetSandboxFlag007");
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("test.dlp"));
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_TRUE(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, "GetSandboxFlag013");
421 OHOS::AAFwk::Want want;
422
423 want.SetAction(TAG_ACTION_VIEW);
424
425 WantParams TopParam;
426 WantParams fileNameParam;
427 fileNameParam.SetParam(TAG_FILE_NAME_VALUE, String::Box("test.nosuffix.dlp"));
428 TopParam.SetParam(TAG_FILE_NAME, WantParamWrapper::Box(fileNameParam));
429
430 WantParams fileFdParam;
431 fileFdParam.SetParam(TAG_KEY_FD_TYPE, String::Box(VALUE_KEY_FD_TYPE));
432 fileFdParam.SetParam(TAG_KEY_FD_VALUE, Integer::Box(g_dlpFileFd));
433 TopParam.SetParam(TAG_KEY_FD, WantParamWrapper::Box(fileFdParam));
434 want.SetParams(TopParam);
435
436 ASSERT_TRUE(DlpFileKits::GetSandboxFlag(want));
437 ASSERT_TRUE((want.GetType() == ""));
438 }
439