1 /*
2 * Copyright (c) 2023-2024 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_permission_serializer_test.h"
17 #include <cerrno>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include "dlp_os_account_mock.h"
21 #include "dlp_permission.h"
22 #include "dlp_permission_log.h"
23 #define private public
24 #include "dlp_permission_serializer.h"
25 #undef private
26
27 using namespace testing::ext;
28 using namespace OHOS;
29 using namespace OHOS::Security::DlpPermission;
30 using namespace OHOS::Security::DlpPermissionUnitTest;
31 using namespace std;
32
33 namespace {
34 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
35 LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpPermissionSerializerTest"};
36 }
37
SetUpTestCase()38 void DlpPermissionSerializerTest::SetUpTestCase() {}
39
TearDownTestCase()40 void DlpPermissionSerializerTest::TearDownTestCase() {}
41
SetUp()42 void DlpPermissionSerializerTest::SetUp() {}
43
TearDown()44 void DlpPermissionSerializerTest::TearDown() {}
45
46 /**
47 * @tc.name: SerializeDlpPermission001
48 * @tc.desc: SerializeDlpPermission test
49 * @tc.type: FUNC
50 * @tc.require:
51 */
52 HWTEST_F(DlpPermissionSerializerTest, SerializeDlpPermission001, TestSize.Level1)
53 {
54 DLP_LOG_INFO(LABEL, "SerializeDlpPermission001");
55
56 std::vector<AuthUserInfo> authUsers;
57 AuthUserInfo info;
58 info.authPerm = DLPFileAccess::CONTENT_EDIT;
59 authUsers.push_back(info);
60 AuthUserInfo info1;
61 info1.authPerm = DLPFileAccess::FULL_CONTROL;
62 authUsers.push_back(info1);
63 AuthUserInfo info2;
64 info2.authPerm = DLPFileAccess::NO_PERMISSION;
65 authUsers.push_back(info2);
66
67 PermissionPolicy policy;
68 policy.authUsers_ = authUsers;
69 unordered_json permInfoJson;
70
71 DlpPermissionSerializer serialize;
72 int32_t ret = serialize.SerializeDlpPermission(policy, permInfoJson);
73 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
74 }
75
76 /**
77 * @tc.name: SerializeDlpPermission002
78 * @tc.desc: SerializeDlpPermission test
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(DlpPermissionSerializerTest, SerializeDlpPermission002, TestSize.Level1)
83 {
84 DLP_LOG_INFO(LABEL, "SerializeDlpPermission002");
85 char aeskey[AESKEY_STR_LEN] = "1234567890123456789012345678901234567890123456789012345678901234";
86
87 PermissionPolicy policy;
88 policy.SetAeskey(reinterpret_cast<uint8_t*>(aeskey), AESKEY_LEN);
89 unordered_json permInfoJson;
90
91 DlpPermissionSerializer serialize;
92 int32_t ret = serialize.SerializeDlpPermission(policy, permInfoJson);
93 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
94 }
95
96 /**
97 * @tc.name: SerializeDlpPermission003
98 * @tc.desc: SerializeDlpPermission test
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(DlpPermissionSerializerTest, SerializeDlpPermission003, TestSize.Level1)
103 {
104 DLP_LOG_INFO(LABEL, "SerializeDlpPermission003");
105 char aesKey[AESKEY_STR_LEN] = "1234567890123456789012345678901234567890123456789012345678901234";
106 char ivKey[IVKEY_STR_LEN] = "12345678901234567890123456789012";
107 char hmacKey[HMACKEY_STR_LEN] = "1234567890123456789012345678901234567890123456789012345678901234";
108
109 PermissionPolicy policy1;
110 policy1.supportEveryone_ = true;
111 policy1.everyonePerm_ = DLPFileAccess::CONTENT_EDIT;
112 policy1.SetAeskey(reinterpret_cast<uint8_t*>(aesKey), AESKEY_LEN);
113 policy1.SetIv(reinterpret_cast<uint8_t*>(ivKey), IVKEY_LEN);
114 policy1.SetHmacKey(reinterpret_cast<uint8_t*>(hmacKey), HMACKEY_LEN);
115
116 PermissionPolicy policy2;
117 policy2.supportEveryone_ = true;
118 policy2.everyonePerm_ = DLPFileAccess::FULL_CONTROL;
119 policy2.SetAeskey(reinterpret_cast<uint8_t*>(aesKey), AESKEY_LEN);
120 policy2.SetIv(reinterpret_cast<uint8_t*>(ivKey), IVKEY_LEN);
121 policy2.SetHmacKey(reinterpret_cast<uint8_t*>(hmacKey), HMACKEY_LEN);
122
123 PermissionPolicy policy3;
124 policy3.supportEveryone_ = true;
125 policy3.everyonePerm_ = DLPFileAccess::NO_PERMISSION;
126 policy3.SetAeskey(reinterpret_cast<uint8_t*>(aesKey), AESKEY_LEN);
127 policy3.SetIv(reinterpret_cast<uint8_t*>(ivKey), IVKEY_LEN);
128 policy3.SetHmacKey(reinterpret_cast<uint8_t*>(hmacKey), HMACKEY_LEN);
129
130 unordered_json permInfoJson;
131 DlpPermissionSerializer serialize;
132 int32_t ret = serialize.SerializeDlpPermission(policy1, permInfoJson);
133 ASSERT_EQ(DLP_OK, ret);
134
135 ret = serialize.SerializeDlpPermission(policy2, permInfoJson);
136 ASSERT_EQ(DLP_OK, ret);
137
138 ret = serialize.SerializeDlpPermission(policy3, permInfoJson);
139 ASSERT_EQ(DLP_OK, ret);
140 }
141
142 /**
143 * @tc.name: SerializeDlpPermission004
144 * @tc.desc: SerializeDlpPermission test
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(DlpPermissionSerializerTest, SerializeDlpPermission004, TestSize.Level1)
149 {
150 DLP_LOG_INFO(LABEL, "SerializeDlpPermission004");
151 PermissionPolicy policy;
152 policy.ownerAccountType_ = OHOS::Security::DlpPermission::DOMAIN_ACCOUNT;
153 unordered_json permInfoJson;
154
155 DlpPermissionSerializer serialize;
156 int32_t ret = serialize.SerializeDlpPermission(policy, permInfoJson);
157 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
158 }
159
160 /**
161 * @tc.name: SerializeDlpPermission005
162 * @tc.desc: SerializeDlpPermission test
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(DlpPermissionSerializerTest, SerializeDlpPermission005, TestSize.Level1)
167 {
168 DLP_LOG_INFO(LABEL, "SerializeDlpPermission005");
169 PermissionPolicy policy;
170 policy.ownerAccountType_ = OHOS::Security::DlpPermission::DOMAIN_ACCOUNT;
171 unordered_json permInfoJson;
172 std::string paramJson = R"({"parameters":{"adConfig":{"adDomain":"test"}}})";
173 SetAccountServerConfigParameters(paramJson);
174 DlpPermissionSerializer serialize;
175 int32_t ret = serialize.SerializeDlpPermission(policy, permInfoJson);
176 ASSERT_EQ(DLP_SERVICE_ERROR_JSON_OPERATE_FAIL, ret);
177
178 paramJson = R"({"adConfig":{"adDomain":"test"},"type":"AD"})";
179 SetAccountServerConfigParameters(paramJson);
180 ret = serialize.SerializeDlpPermission(policy, permInfoJson);
181 ASSERT_EQ(DLP_SERVICE_ERROR_JSON_OPERATE_FAIL, ret);
182
183 paramJson = R"({[]})";
184 SetAccountServerConfigParameters(paramJson);
185 ret = serialize.SerializeDlpPermission(policy, permInfoJson);
186 ASSERT_EQ(DLP_SERVICE_ERROR_JSON_OPERATE_FAIL, ret);
187 }
188
189 /**
190 * @tc.name: DeserializeDlpPermission001
191 * @tc.desc: DeserializeDlpPermission test
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(DlpPermissionSerializerTest, DeserializeDlpPermission001, TestSize.Level1)
196 {
197 DLP_LOG_INFO(LABEL, "DeserializeDlpPermission001");
198
199 unordered_json permJson;
200 PermissionPolicy policy;
201 permJson["plaintextPolicy"] = "7b2266696c65223a7b226976223a223132222c2269764c656e223a31367d7d";
202
203 DlpPermissionSerializer serialize;
204 int32_t ret = serialize.DeserializeDlpPermission(permJson, policy);
205 ASSERT_EQ(DLP_OK, ret);
206 }
207
208 /**
209 * @tc.name: DeserializeDlpPermission002
210 * @tc.desc: DeserializeDlpPermission test
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(DlpPermissionSerializerTest, DeserializeDlpPermission002, TestSize.Level1)
215 {
216 DLP_LOG_INFO(LABEL, "DeserializeDlpPermission002");
217
218 unordered_json permJson;
219 PermissionPolicy policy;
220 permJson["file"] = {{"filekey", "ttttt"}, {"filekeyLen", AESKEY_LEN}};
221
222 DlpPermissionSerializer serialize;
223 int32_t ret = serialize.DeserializeDlpPermission(permJson, policy);
224 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
225 }
226
227 /**
228 * @tc.name: DeserializeDlpPermission003
229 * @tc.desc: DeserializeDlpPermission test
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(DlpPermissionSerializerTest, DeserializeDlpPermission003, TestSize.Level1)
234 {
235 DLP_LOG_INFO(LABEL, "DeserializeDlpPermission003");
236
237 unordered_json permJson;
238 PermissionPolicy policy;
239 permJson["file"] = {{"iv", "ttttt"}, {"ivLen", AESKEY_LEN}};
240
241 DlpPermissionSerializer serialize;
242 int32_t ret = serialize.DeserializeDlpPermission(permJson, policy);
243 ASSERT_EQ(DLP_SERVICE_ERROR_VALUE_INVALID, ret);
244 }
245
246 /**
247 * @tc.name: DeserializeDlpPermission004
248 * @tc.desc: DeserializeDlpPermission test
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(DlpPermissionSerializerTest, DeserializeDlpPermission004, TestSize.Level1)
253 {
254 DLP_LOG_INFO(LABEL, "DeserializeDlpPermission004");
255
256 unordered_json permJson1;
257 permJson1["policy"] = {{"account", {"right", {"edit", true}}}};
258
259 unordered_json permJson2;
260 permJson2["policy"] = {{"account", {"right", {"fullCtrl", true}}}};
261
262 PermissionPolicy policy;
263 DlpPermissionSerializer serialize;
264 int32_t ret = serialize.DeserializeDlpPermission(permJson1, policy);
265 ASSERT_EQ(DLP_OK, ret);
266
267 ret = serialize.DeserializeDlpPermission(permJson2, policy);
268 ASSERT_EQ(DLP_OK, ret);
269 }
270
271 /**
272 * @tc.name: DeserializeEncPolicyData001
273 * @tc.desc: DeserializeEncPolicyData test
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(DlpPermissionSerializerTest, DeserializeEncPolicyData001, TestSize.Level1)
278 {
279 DLP_LOG_INFO(LABEL, "DeserializeEncPolicyData001");
280
281 unordered_json permJson1;
282 DLP_EncPolicyData encData;
283 DlpPermissionSerializer serialize;
284 int32_t ret = serialize.DeserializeEncPolicyData(permJson1, encData, true);
285 ASSERT_EQ(DLP_OK, ret);
286 }
287
288 /**
289 * @tc.name: DeserializeEncPolicyData002
290 * @tc.desc: DeserializeEncPolicyData test
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(DlpPermissionSerializerTest, DeserializeEncPolicyData002, TestSize.Level1)
295 {
296 DLP_LOG_INFO(LABEL, "DeserializeEncPolicyData002");
297
298 unordered_json permJson1;
299 permJson1["encData"] = "X";
300 permJson1["encDataLen"] = 11;
301 DLP_EncPolicyData encData;
302 DlpPermissionSerializer serialize;
303 int32_t ret = serialize.DeserializeEncPolicyData(permJson1, encData, false);
304 ASSERT_NE(DLP_OK, ret);
305 }
306
307 /**
308 * @tc.name: DeserializeEveryoneInfo001
309 * @tc.desc: DeserializeEveryoneInfo test
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(DlpPermissionSerializerTest, DeserializeEveryoneInfo001, TestSize.Level1)
314 {
315 DLP_LOG_INFO(LABEL, "DeserializeEveryoneInfo001");
316
317 unordered_json permJson1;
318 unordered_json rightInfoJson;
319 unordered_json everyoneJson;
320 rightInfoJson["read"] = true;
321 everyoneJson["right1"] = rightInfoJson;
322 permJson1["everyone"] = everyoneJson;
323 PermissionPolicy policy;
324 DlpPermissionSerializer serialize;
325 bool ret = serialize.DeserializeEveryoneInfo(permJson1, policy);
326 ASSERT_EQ(false, ret);
327 everyoneJson["right"] = 1;
328 permJson1["everyone"] = everyoneJson;
329 ret = serialize.DeserializeEveryoneInfo(permJson1, policy);
330 ASSERT_EQ(false, ret);
331 rightInfoJson["edit"] = "true";
332 rightInfoJson["fullCtrl"] = "true";
333 everyoneJson["right"] = rightInfoJson;
334 permJson1["everyone"] = everyoneJson;
335 ret = serialize.DeserializeEveryoneInfo(permJson1, policy);
336 ASSERT_EQ(true, ret);
337 rightInfoJson["edit"] = true;
338 everyoneJson["right"] = rightInfoJson;
339 permJson1["everyone"] = everyoneJson;
340 ret = serialize.DeserializeEveryoneInfo(permJson1, policy);
341 ASSERT_EQ(true, ret);
342 rightInfoJson["fullCtrl"] = true;
343 everyoneJson["right"] = rightInfoJson;
344 permJson1["everyone"] = everyoneJson;
345 ret = serialize.DeserializeEveryoneInfo(permJson1, policy);
346 ASSERT_EQ(true, ret);
347 }
348
349 /**
350 * @tc.name: DeserializeAuthUserInfo001
351 * @tc.desc: DeserializeAuthUserInfo test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(DlpPermissionSerializerTest, DeserializeAuthUserInfo001, TestSize.Level1)
356 {
357 DLP_LOG_INFO(LABEL, "DeserializeAuthUserInfo001");
358
359 unordered_json permJson1;
360 unordered_json rightInfoJson;
361 unordered_json everyoneJson;
362 rightInfoJson["read"] = true;
363 everyoneJson["right1"] = rightInfoJson;
364 permJson1["everyone"] = everyoneJson;
365 AuthUserInfo userInfo;
366 DlpPermissionSerializer serialize;
367 int32_t ret = serialize.DeserializeAuthUserInfo(permJson1, userInfo);
368 ASSERT_EQ(DLP_OK, ret);
369 everyoneJson["right"] = 1;
370 permJson1["everyone"] = everyoneJson;
371 ret = serialize.DeserializeAuthUserInfo(permJson1, userInfo);
372 ASSERT_EQ(DLP_OK, ret);
373 rightInfoJson["edit"] = "true";
374 rightInfoJson["fullCtrl"] = "true";
375 everyoneJson["right"] = rightInfoJson;
376 permJson1["everyone"] = everyoneJson;
377 ret = serialize.DeserializeAuthUserInfo(permJson1, userInfo);
378 ASSERT_EQ(DLP_OK, ret);
379 rightInfoJson["edit"] = true;
380 everyoneJson["right"] = rightInfoJson;
381 permJson1["everyone"] = everyoneJson;
382 ret = serialize.DeserializeAuthUserInfo(permJson1, userInfo);
383 ASSERT_EQ(DLP_OK, ret);
384 rightInfoJson["fullCtrl"] = true;
385 everyoneJson["right"] = rightInfoJson;
386 permJson1["everyone"] = everyoneJson;
387 ret = serialize.DeserializeAuthUserInfo(permJson1, userInfo);
388 ASSERT_EQ(DLP_OK, ret);
389 }