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