1 /*
2 * Copyright (c) 2022 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 <gtest/gtest.h>
17 #include <memory>
18 #include <string>
19
20 #include "access_token.h"
21 #include "atm_tools_param_info_parcel.h"
22 #include "hap_info_parcel.h"
23 #include "hap_policy_parcel.h"
24 #include "hap_token_info_parcel.h"
25 #include "hap_token_info_for_sync_parcel.h"
26 #include "native_token_info_parcel.h"
27 #include "parcel.h"
28 #include "parcel_utils.h"
29 #include "permission_grant_info_parcel.h"
30 #include "perm_state_change_scope_parcel.h"
31 #include "permission_state_change_info_parcel.h"
32 #include "permission_status_parcel.h"
33
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace Security {
38 namespace AccessToken {
39 namespace {
40 static constexpr int32_t DEFAULT_API_VERSION = 8;
41 static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA";
42 static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA";
43 static constexpr AccessTokenID TEST_TOKEN_ID = 10002;
44 static constexpr int32_t TEST_PERMSTATE_CHANGE_TYPE = 10001;
45
46 PermissionDef g_permDefAlpha = {
47 .permissionName = TEST_PERMISSION_NAME_ALPHA,
48 .bundleName = "accesstoken_test",
49 .grantMode = 1,
50 .availableLevel = APL_NORMAL,
51 .label = "label",
52 .labelId = 1,
53 .description = "annoying",
54 .descriptionId = 1
55 };
56 PermissionDef g_permDefBeta = {
57 .permissionName = TEST_PERMISSION_NAME_BETA,
58 .bundleName = "accesstoken_test",
59 .grantMode = 1,
60 .availableLevel = APL_NORMAL,
61 .label = "label",
62 .labelId = 1,
63 .description = "so trouble",
64 .descriptionId = 1
65 };
66
67 PermissionStatus g_permStatAlpha = {
68 .permissionName = TEST_PERMISSION_NAME_ALPHA,
69 .grantStatus = PermissionState::PERMISSION_DENIED,
70 .grantFlag = PermissionFlag::PERMISSION_USER_SET
71 };
72 PermissionStatus g_permStatBeta = {
73 .permissionName = TEST_PERMISSION_NAME_BETA,
74 .grantStatus = PermissionState::PERMISSION_GRANTED,
75 .grantFlag = PermissionFlag::PERMISSION_SYSTEM_FIXED
76 };
77 }
78 class AccessTokenParcelTest : public testing::Test {
79 public:
80 static void SetUpTestCase(void);
81 static void TearDownTestCase(void);
82 void SetUp();
83 void TearDown();
84 };
85
SetUpTestCase(void)86 void AccessTokenParcelTest::SetUpTestCase(void) {}
TearDownTestCase(void)87 void AccessTokenParcelTest::TearDownTestCase(void) {}
SetUp(void)88 void AccessTokenParcelTest::SetUp(void) {}
TearDown(void)89 void AccessTokenParcelTest::TearDown(void) {}
90
91 /**
92 * @tc.name: HapInfoParcel001
93 * @tc.desc: Test HapInfo Marshalling/Unmarshalling.
94 * @tc.type: FUNC
95 * @tc.require: issueI5QKZF
96 */
97 HWTEST_F(AccessTokenParcelTest, HapInfoParcel001, TestSize.Level1)
98 {
99 HapInfoParcel hapinfoParcel;
100 hapinfoParcel.hapInfoParameter = {
101 .userID = 1,
102 .bundleName = "accesstoken_test",
103 .instIndex = 0,
104 .appIDDesc = "testtesttesttest",
105 .apiVersion = DEFAULT_API_VERSION,
106 .isSystemApp = false,
107 };
108
109 Parcel parcel;
110 EXPECT_EQ(true, hapinfoParcel.Marshalling(parcel));
111
112 std::shared_ptr<HapInfoParcel> readedData(HapInfoParcel::Unmarshalling(parcel));
113 EXPECT_NE(nullptr, readedData);
114
115 EXPECT_EQ(hapinfoParcel.hapInfoParameter.userID, readedData->hapInfoParameter.userID);
116 EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.bundleName == readedData->hapInfoParameter.bundleName);
117 EXPECT_EQ(hapinfoParcel.hapInfoParameter.instIndex, readedData->hapInfoParameter.instIndex);
118 EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.appIDDesc == readedData->hapInfoParameter.appIDDesc);
119 EXPECT_EQ(hapinfoParcel.hapInfoParameter.apiVersion, readedData->hapInfoParameter.apiVersion);
120 EXPECT_EQ(hapinfoParcel.hapInfoParameter.isSystemApp, readedData->hapInfoParameter.isSystemApp);
121 }
122
123 /**
124 * @tc.name: HapPolicyParcel001
125 * @tc.desc: Test HapPolicy Marshalling/Unmarshalling.
126 * @tc.type: FUNC
127 * @tc.require: issueI5QKZF
128 */
129 HWTEST_F(AccessTokenParcelTest, HapPolicyParcel001, TestSize.Level1)
130 {
131 HapPolicyParcel hapPolicyParcel;
132
133 hapPolicyParcel.hapPolicy.apl = ATokenAplEnum::APL_NORMAL;
134 hapPolicyParcel.hapPolicy.domain = "test.domain";
135 hapPolicyParcel.hapPolicy.permList.emplace_back(g_permDefAlpha);
136 hapPolicyParcel.hapPolicy.permList.emplace_back(g_permDefBeta);
137 hapPolicyParcel.hapPolicy.permStateList.emplace_back(g_permStatAlpha);
138 hapPolicyParcel.hapPolicy.permStateList.emplace_back(g_permStatBeta);
139
140 Parcel parcel;
141 EXPECT_EQ(true, hapPolicyParcel.Marshalling(parcel));
142
143 std::shared_ptr<HapPolicyParcel> readedData(HapPolicyParcel::Unmarshalling(parcel));
144 EXPECT_NE(nullptr, readedData);
145
146 EXPECT_EQ(hapPolicyParcel.hapPolicy.apl, readedData->hapPolicy.apl);
147 EXPECT_EQ(hapPolicyParcel.hapPolicy.domain, readedData->hapPolicy.domain);
148 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList.size(), readedData->hapPolicy.permList.size());
149 EXPECT_EQ(hapPolicyParcel.hapPolicy.permStateList.size(),
150 readedData->hapPolicy.permStateList.size());
151
152 for (uint32_t i = 0; i < hapPolicyParcel.hapPolicy.permList.size(); i++) {
153 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].permissionName,
154 readedData->hapPolicy.permList[i].permissionName);
155 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].bundleName,
156 readedData->hapPolicy.permList[i].bundleName);
157 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].grantMode,
158 readedData->hapPolicy.permList[i].grantMode);
159 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].availableLevel,
160 readedData->hapPolicy.permList[i].availableLevel);
161 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].label,
162 readedData->hapPolicy.permList[i].label);
163 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].labelId,
164 readedData->hapPolicy.permList[i].labelId);
165 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].description,
166 readedData->hapPolicy.permList[i].description);
167 EXPECT_EQ(hapPolicyParcel.hapPolicy.permList[i].descriptionId,
168 readedData->hapPolicy.permList[i].descriptionId);
169 }
170
171 for (uint32_t i = 0; i < hapPolicyParcel.hapPolicy.permStateList.size(); i++) {
172 EXPECT_EQ(hapPolicyParcel.hapPolicy.permStateList[i].permissionName,
173 readedData->hapPolicy.permStateList[i].permissionName);
174 EXPECT_EQ(hapPolicyParcel.hapPolicy.permStateList[i].grantStatus,
175 readedData->hapPolicy.permStateList[i].grantStatus);
176 EXPECT_EQ(hapPolicyParcel.hapPolicy.permStateList[i].grantFlag,
177 readedData->hapPolicy.permStateList[i].grantFlag);
178 }
179 }
180
181 /**
182 * @tc.name: PermissionStateChangeInfoParcel001
183 * @tc.desc: Test PermissionStateChangeInfo Marshalling/Unmarshalling.
184 * @tc.type: FUNC
185 * @tc.require: issueI5QKZF
186 */
187 HWTEST_F(AccessTokenParcelTest, PermissionStateChangeInfoParcel001, TestSize.Level1)
188 {
189 PermissionStateChangeInfoParcel permissionStateParcel;
190 permissionStateParcel.changeInfo.permStateChangeType = TEST_PERMSTATE_CHANGE_TYPE;
191 permissionStateParcel.changeInfo.tokenID = TEST_TOKEN_ID;
192 permissionStateParcel.changeInfo.permissionName = TEST_PERMISSION_NAME_ALPHA;
193
194 Parcel parcel;
195 EXPECT_EQ(true, permissionStateParcel.Marshalling(parcel));
196
197 std::shared_ptr<PermissionStateChangeInfoParcel> readedData(PermissionStateChangeInfoParcel::Unmarshalling(parcel));
198 EXPECT_NE(nullptr, readedData);
199 EXPECT_EQ(permissionStateParcel.changeInfo.permStateChangeType, readedData->changeInfo.permStateChangeType);
200 EXPECT_EQ(permissionStateParcel.changeInfo.tokenID, readedData->changeInfo.tokenID);
201 EXPECT_EQ(permissionStateParcel.changeInfo.permissionName, readedData->changeInfo.permissionName);
202 }
203
204 /**
205 * @tc.name: PermStateChangeScopeParcel001
206 * @tc.desc: Test PermStateChangeScope Marshalling/Unmarshalling.
207 * @tc.type: FUNC
208 * @tc.require: issueI5QKZF
209 */
210 HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1)
211 {
212 PermStateChangeScopeParcel permStateChangeScopeParcel;
213 permStateChangeScopeParcel.scope.tokenIDs.emplace_back(TEST_TOKEN_ID);
214 permStateChangeScopeParcel.scope.permList.emplace_back(TEST_PERMISSION_NAME_ALPHA);
215
216 Parcel parcel;
217 EXPECT_EQ(true, permStateChangeScopeParcel.Marshalling(parcel));
218
219 std::shared_ptr<PermStateChangeScopeParcel> readedData(PermStateChangeScopeParcel::Unmarshalling(parcel));
220 EXPECT_NE(nullptr, readedData);
221
222 EXPECT_EQ(true, permStateChangeScopeParcel.scope.tokenIDs.size() == readedData->scope.tokenIDs.size());
223 EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList.size() == readedData->scope.permList.size());
224
225 for (uint32_t i = 0; i < readedData->scope.tokenIDs.size(); i++) {
226 EXPECT_EQ(permStateChangeScopeParcel.scope.tokenIDs[i], readedData->scope.tokenIDs[i]);
227 }
228 for (uint32_t i = 0; i < readedData->scope.permList.size(); i++) {
229 EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList[i] == readedData->scope.permList[i]);
230 }
231 }
232
233 /**
234 * @tc.name: HapTokenInfoForSyncParcel001
235 * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
236 * @tc.type: FUNC
237 * @tc.require: issueI5QKZF
238 */
239 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel001, TestSize.Level1)
240 {
241 HapTokenInfoForSyncParcel hapTokenInfoSync;
242
243 HapTokenInfo hapTokenInfo;
244 hapTokenInfo.ver = 0;
245 hapTokenInfo.userID = 2;
246 hapTokenInfo.bundleName = "bundle1";
247 hapTokenInfo.apiVersion = 8;
248 hapTokenInfo.instIndex = 0;
249 hapTokenInfo.dlpType = 0;
250 hapTokenInfo.tokenID = 0x53100000;
251 hapTokenInfo.tokenAttr = 0;
252 hapTokenInfoSync.hapTokenInfoForSyncParams.baseInfo = hapTokenInfo;
253 hapTokenInfoSync.hapTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta);
254
255 Parcel parcel;
256 EXPECT_EQ(true, hapTokenInfoSync.Marshalling(parcel));
257 std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(parcel));
258 EXPECT_NE(nullptr, readedData);
259 }
260
WriteParcelable(Parcel & out,const Parcelable & baseInfoParcel,uint32_t size)261 static void WriteParcelable(
262 Parcel& out, const Parcelable& baseInfoParcel, uint32_t size)
263 {
264 out.WriteParcelable(&baseInfoParcel);
265 std::vector<PermissionStatus> permStateList;
266 for (uint32_t i = 0; i < size; i++) {
267 permStateList.emplace_back(g_permStatBeta);
268 }
269 uint32_t permStateListSize = permStateList.size();
270 out.WriteUint32(permStateListSize);
271 for (uint32_t i = 0; i < permStateListSize; i++) {
272 PermissionStatusParcel permStateParcel;
273 permStateParcel.permState = permStateList[i];
274 out.WriteParcelable(&permStateParcel);
275 }
276
277 out.WriteParcelable(&baseInfoParcel);
278 permStateList.emplace_back(g_permStatBeta);
279
280 permStateListSize = permStateList.size();
281 out.WriteUint32(permStateListSize);
282 for (uint32_t i = 0; i < permStateListSize; i++) {
283 PermissionStatusParcel permStateParcel;
284 permStateParcel.permState = permStateList[i];
285 out.WriteParcelable(&permStateParcel);
286 }
287 }
288
289 /**
290 * @tc.name: HapTokenInfoForSyncParcel002
291 * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling.
292 * @tc.type: FUNC
293 * @tc.require: issueI5QKZF
294 */
295 HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel002, TestSize.Level1)
296 {
297 HapTokenInfoForSyncParcel hapTokenInfoSync;
298
299 HapTokenInfo hapTokenInfo;
300 hapTokenInfo.ver = 0;
301 hapTokenInfo.userID = 2;
302 hapTokenInfo.bundleName = "bundle2";
303 hapTokenInfo.apiVersion = 8;
304 hapTokenInfo.instIndex = 0;
305 hapTokenInfo.dlpType = 0;
306 hapTokenInfo.tokenID = 0x53100000;
307 hapTokenInfo.tokenAttr = 0;
308
309 Parcel out;
310 HapTokenInfoParcel baseInfoParcel;
311 baseInfoParcel.hapTokenInfoParams = hapTokenInfo;
312 WriteParcelable(out, baseInfoParcel, MAX_PERMLIST_SIZE);
313
314 std::shared_ptr<HapTokenInfoForSyncParcel> readedData(HapTokenInfoForSyncParcel::Unmarshalling(out));
315 EXPECT_NE(nullptr, readedData);
316
317 Parcel out1;
318 WriteParcelable(out1, baseInfoParcel, MAX_PERMLIST_SIZE + 1);
319 std::shared_ptr<HapTokenInfoForSyncParcel> readedData1(HapTokenInfoForSyncParcel::Unmarshalling(out1));
320 EXPECT_EQ(true, readedData1 == nullptr);
321 }
322
323 /**
324 * @tc.name: PermissionStateFullParcel002
325 * @tc.desc: Test permissionStateParcel Marshalling/Unmarshalling.
326 * @tc.type: FUNC
327 * @tc.require: issueI5QKZF
328 */
329 HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel002, TestSize.Level1)
330 {
331 PermissionStatusParcel permissionStateParcel;
332 permissionStateParcel.permState.permissionName = "permissionName";
333 permissionStateParcel.permState.grantStatus = 1;
334 permissionStateParcel.permState.grantFlag = 0;
335 Parcel parcel;
336 EXPECT_EQ(true, permissionStateParcel.Marshalling(parcel));
337
338 std::shared_ptr<PermissionStatusParcel> readedData(PermissionStatusParcel::Unmarshalling(parcel));
339 EXPECT_NE(nullptr, readedData);
340 }
341
342 /**
343 * @tc.name: PermissionGrantInfoParcel001
344 * @tc.desc: Test PermissionGrantInfo Marshalling/Unmarshalling.
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(AccessTokenParcelTest, PermissionGrantInfoParcel001, TestSize.Level1)
349 {
350 PermissionGrantInfoParcel permissionGrantInfoParcel;
351 permissionGrantInfoParcel.info.grantBundleName = "com.ohos.permissionmanager";
352 permissionGrantInfoParcel.info.grantAbilityName = "com.ohos.permissionmanager.GrantAbility";
353
354 Parcel parcel;
355 EXPECT_EQ(true, permissionGrantInfoParcel.Marshalling(parcel));
356 std::shared_ptr<PermissionGrantInfoParcel> readedData(PermissionGrantInfoParcel::Unmarshalling(parcel));
357 EXPECT_NE(nullptr, readedData);
358 }
359
360 /**
361 * @tc.name: AtmToolsParamInfoParcel001
362 * @tc.desc: Test AtmToolsParamInfo Marshalling/Unmarshalling.
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(AccessTokenParcelTest, AtmToolsParamInfoParcel001, TestSize.Level1)
367 {
368 AtmToolsParamInfoParcel atmToolsParamInfoParcel;
369 atmToolsParamInfoParcel.info.tokenId = INVALID_TOKENID;
370 atmToolsParamInfoParcel.info.permissionName = "ohos.permission.CAMERA";
371 atmToolsParamInfoParcel.info.bundleName = "com.ohos.parceltest";
372 atmToolsParamInfoParcel.info.permissionName = "test_service";
373
374 Parcel parcel;
375 EXPECT_EQ(true, atmToolsParamInfoParcel.Marshalling(parcel));
376 std::shared_ptr<AtmToolsParamInfoParcel> readedData(AtmToolsParamInfoParcel::Unmarshalling(parcel));
377 EXPECT_NE(nullptr, readedData);
378 }
379 } // namespace AccessToken
380 } // namespace Security
381 } // namespace OHOS
382