1 /*
2 * Copyright (c) 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 "alloc_hap_token_test.h"
17 #include "gtest/gtest.h"
18 #include <thread>
19
20 #include "access_token.h"
21 #include "access_token_error.h"
22 #include "accesstoken_common_log.h"
23 #include "accesstoken_service_ipc_interface_code.h"
24 #include "nativetoken_kit.h"
25 #include "permission_grant_info.h"
26 #include "permission_state_change_info_parcel.h"
27 #include "string_ex.h"
28 #include "test_common.h"
29 #include "tokenid_kit.h"
30 #include "token_setproc.h"
31
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace Security {
35 namespace AccessToken {
36 namespace {
37 static constexpr int32_t DEFAULT_API_VERSION = 8;
38 static uint64_t g_selfTokenId = 0;
39 static const int32_t INDEX_ZERO = 0;
40 static const int32_t INDEX_ONE = 1;
41 static const int INVALID_BUNDLENAME_LEN = 260;
42 static const int INVALID_APPIDDESC_LEN = 10244;
43 static const int INVALID_LABEL_LEN = 260;
44 static const int INVALID_DESCRIPTION_LEN = 260;
45 static const int INVALID_PERMNAME_LEN = 260;
46 static const int CYCLE_TIMES = 100;
47 static const int INVALID_DLP_TYPE = 4;
48 static MockNativeToken* g_mock;
49
50 HapInfoParams g_infoManagerTestInfoParms = {
51 .userID = 1,
52 .bundleName = "accesstoken_test",
53 .instIndex = 0,
54 .appIDDesc = "test3",
55 .apiVersion = DEFAULT_API_VERSION,
56 .appDistributionType = "enterprise_mdm"
57 };
58
59 PermissionDef g_infoManagerTestPermDef1 = {
60 .permissionName = "ohos.permission.test1",
61 .bundleName = "accesstoken_test",
62 .grantMode = 1,
63 .availableLevel = APL_NORMAL,
64 .label = "label3",
65 .labelId = 1,
66 .description = "open the door",
67 .descriptionId = 1,
68 .availableType = MDM
69 };
70
71 PermissionDef g_infoManagerTestPermDef2 = {
72 .permissionName = "ohos.permission.test2",
73 .bundleName = "accesstoken_test",
74 .grantMode = 1,
75 .availableLevel = APL_NORMAL,
76 .label = "label3",
77 .labelId = 1,
78 .description = "break the door",
79 .descriptionId = 1,
80 };
81
82 PermissionStateFull g_infoManagerTestState1 = {
83 .permissionName = "ohos.permission.test1",
84 .isGeneral = true,
85 .resDeviceID = {"local3"},
86 .grantStatus = {PermissionState::PERMISSION_GRANTED},
87 .grantFlags = {1}
88 };
89
90 PermissionStateFull g_infoManagerTestState2 = {
91 .permissionName = "ohos.permission.test2",
92 .isGeneral = false,
93 .resDeviceID = {"device 1", "device 2"},
94 .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED},
95 .grantFlags = {1, 2}
96 };
97
98 HapPolicyParams g_infoManagerTestPolicyPrams = {
99 .apl = APL_NORMAL,
100 .domain = "test.domain3",
101 .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2},
102 .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2}
103 };
104 };
105
SetUpTestCase()106 void AllocHapTokenTest::SetUpTestCase()
107 {
108 g_selfTokenId = GetSelfTokenID();
109 TestCommon::SetTestEvironment(g_selfTokenId);
110
111 g_mock = new (std::nothrow) MockNativeToken("foundation");
112
113 // make test case clean
114 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
115 g_infoManagerTestInfoParms.bundleName,
116 g_infoManagerTestInfoParms.instIndex);
117 AccessTokenKit::DeleteToken(tokenID);
118 }
119
TearDownTestCase()120 void AllocHapTokenTest::TearDownTestCase()
121 {
122 if (g_mock != nullptr) {
123 delete g_mock;
124 g_mock = nullptr;
125 }
126 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
127 TestCommon::ResetTestEvironment();
128 }
129
AllocTestToken(const HapInfoParams & hapInfo,const HapPolicyParams & hapPolicy) const130 AccessTokenID AllocHapTokenTest::AllocTestToken(
131 const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const
132 {
133 AccessTokenIDEx tokenIdEx = {0};
134 tokenIdEx = AccessTokenKit::AllocHapToken(hapInfo, hapPolicy);
135 return tokenIdEx.tokenIdExStruct.tokenID;
136 }
137
GetAccessTokenID(int userID,const std::string & bundleName,int instIndex)138 unsigned int AllocHapTokenTest::GetAccessTokenID(int userID, const std::string& bundleName, int instIndex)
139 {
140 return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex);
141 }
142
DeleteTestToken() const143 void AllocHapTokenTest::DeleteTestToken() const
144 {
145 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
146 g_infoManagerTestInfoParms.bundleName,
147 g_infoManagerTestInfoParms.instIndex);
148 int ret = AccessTokenKit::DeleteToken(tokenID);
149 if (tokenID != 0) {
150 ASSERT_EQ(RET_SUCCESS, ret);
151 }
152 }
153
GetDlpFlagTest(const HapInfoParams & info,const HapPolicyParams & policy,int flag)154 void AllocHapTokenTest::GetDlpFlagTest(const HapInfoParams& info, const HapPolicyParams& policy, int flag)
155 {
156 int32_t ret;
157 HapTokenInfo hapTokenInfoRes;
158 uint32_t tokenID = GetAccessTokenID(info.userID, info.bundleName, 2);
159 if (tokenID != 0) {
160 ret = AccessTokenKit::DeleteToken(tokenID);
161 }
162 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(info, policy);
163 EXPECT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
164 ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes);
165 EXPECT_EQ(ret, RET_SUCCESS);
166 EXPECT_EQ(hapTokenInfoRes.dlpType, flag);
167 if (flag == DLP_COMMON) {
168 EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 0);
169 } else {
170 EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 1);
171 }
172 ret = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID);
173 EXPECT_EQ(RET_SUCCESS, ret);
174 GTEST_LOG_(INFO) << "tokenID :" << tokenIdEx.tokenIdExStruct.tokenID;
175 ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes);
176 EXPECT_EQ(ret, AccessTokenError::ERR_TOKENID_NOT_EXIST);
177 }
178
SetUp()179 void AllocHapTokenTest::SetUp()
180 {
181 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
182 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID,
183 g_infoManagerTestInfoParms.bundleName,
184 g_infoManagerTestInfoParms.instIndex);
185 AccessTokenKit::DeleteToken(tokenID);
186 }
187
TearDown()188 void AllocHapTokenTest::TearDown()
189 {
190 }
191
192 /**
193 * @tc.name: AllocHapToken001
194 * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delete it again.
195 * @tc.type: FUNC
196 * @tc.require: Issue Number
197 */
198 HWTEST_F(AllocHapTokenTest, AllocHapToken001, TestSize.Level1)
199 {
200 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
201 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
202 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
203 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID));
204 ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID));
205 }
206
207 /**
208 * @tc.name: AllocHapToken002
209 * @tc.desc: alloc a tokenId with the same info and policy repeatly,
210 * tokenId will change.
211 * @tc.type: FUNC
212 * @tc.require: Issue Number
213 */
214 HWTEST_F(AllocHapTokenTest, AllocHapToken002, TestSize.Level1)
215 {
216 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
217 GTEST_LOG_(INFO) << "tokenID :" << tokenID;
218 ASSERT_NE(INVALID_TOKENID, tokenID);
219
220 AccessTokenID tokenID1 = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
221 ASSERT_NE(INVALID_TOKENID, tokenID1);
222 ASSERT_NE(tokenID, tokenID1);
223 ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID));
224 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID1));
225 }
226
227 /**
228 * @tc.name: AllocHapToken003
229 * @tc.desc: cannot alloc a tokenId with invalid bundlename.
230 * @tc.type: FUNC
231 * @tc.require: Issue Number
232 */
233 HWTEST_F(AllocHapTokenTest, AllocHapToken003, TestSize.Level1)
234 {
235 std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x');
236 std::string bundle = g_infoManagerTestInfoParms.bundleName;
237
238 DeleteTestToken();
239 GTEST_LOG_(INFO) << "get hap token info:" << invalidBundleName.length();
240
241 g_infoManagerTestInfoParms.bundleName = invalidBundleName;
242 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
243 ASSERT_EQ(INVALID_TOKENID, tokenID);
244
245 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
246 g_infoManagerTestInfoParms.bundleName,
247 g_infoManagerTestInfoParms.instIndex);
248 ASSERT_EQ(INVALID_TOKENID, tokenID);
249 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID));
250
251 g_infoManagerTestInfoParms.bundleName = bundle;
252
253 DeleteTestToken();
254 }
255
256 /**
257 * @tc.name: AllocHapToken004
258 * @tc.desc: cannot alloc a tokenId with invalid apl.
259 * @tc.type: FUNC
260 * @tc.require: Issue Number
261 */
262 HWTEST_F(AllocHapTokenTest, AllocHapToken004, TestSize.Level1)
263 {
264 ATokenAplEnum typeBackUp = g_infoManagerTestPolicyPrams.apl;
265 DeleteTestToken();
266
267 g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5;
268 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
269 ASSERT_EQ(INVALID_TOKENID, tokenID);
270
271 tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID,
272 g_infoManagerTestInfoParms.bundleName,
273 g_infoManagerTestInfoParms.instIndex);
274 ASSERT_EQ(INVALID_TOKENID, tokenID);
275
276 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID));
277 g_infoManagerTestPolicyPrams.apl = typeBackUp;
278
279 DeleteTestToken();
280 }
281
282 /**
283 * @tc.name: AllocHapToken005
284 * @tc.desc: can alloc a tokenId when bundlename in permdef is different with bundlename in info.
285 * @tc.type: FUNC
286 * @tc.require: Issue Number
287 */
288 HWTEST_F(AllocHapTokenTest, AllocHapToken005, TestSize.Level1)
289 {
290 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName;
291 std::string bundleNameBackUp = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName;
292 ATokenAvailableTypeEnum typeBakup = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType;
293 DeleteTestToken();
294
295 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName = "invalid_bundleName";
296 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName = "ohos.permission.testtmp01";
297 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType = MDM;
298 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
299 ASSERT_NE(INVALID_TOKENID, tokenID);
300
301 PermissionDef permDefResult;
302 int ret = AccessTokenKit::GetDefPermission(
303 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResult);
304 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
305 ASSERT_NE(permDefResult.availableType, MDM);
306 ret = AccessTokenKit::GetDefPermission(
307 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResult);
308 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
309 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName = bundleNameBackUp;
310 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName = backUpPermission;
311 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType = typeBakup;
312
313 DeleteTestToken();
314 }
315
316 /**
317 * @tc.name: AllocHapToken006
318 * @tc.desc: can alloc a tokenId with a invalid permList permissionName.
319 * @tc.type: FUNC
320 * @tc.require: Issue Number
321 */
322 HWTEST_F(AllocHapTokenTest, AllocHapToken006, TestSize.Level1)
323 {
324 std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
325 DeleteTestToken();
326
327 const std::string invalidPermissionName (INVALID_PERMNAME_LEN, 'x');
328 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = invalidPermissionName;
329 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
330 ASSERT_NE(INVALID_TOKENID, tokenID);
331
332 PermissionDef permDefResultBeta;
333 int ret = AccessTokenKit::GetDefPermission(invalidPermissionName, permDefResultBeta);
334 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret);
335 ret = AccessTokenKit::GetDefPermission(
336 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta);
337 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
338 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUp;
339
340 DeleteTestToken();
341 }
342
343 /**
344 * @tc.name: AllocHapToken007
345 * @tc.desc: can alloc a tokenId with invalid permdef.
346 * @tc.type: FUNC
347 * @tc.require: Issue Number
348 */
349 HWTEST_F(AllocHapTokenTest, AllocHapToken007, TestSize.Level1)
350 {
351 std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName;
352 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
353 DeleteTestToken();
354
355 const std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x');
356
357 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp02";
358 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = invalidBundleName;
359 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
360 ASSERT_NE(INVALID_TOKENID, tokenID);
361
362 PermissionDef permDefResultBeta;
363 int ret = AccessTokenKit::GetDefPermission(
364 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta);
365 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
366 ret = AccessTokenKit::GetDefPermission(
367 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta);
368 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
369 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = backUp;
370 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
371
372 DeleteTestToken();
373 }
374
375 /**
376 * @tc.name: AllocHapToken008
377 * @tc.desc: can alloc a tokenId with invalid permdef.
378 * @tc.type: FUNC
379 * @tc.require: Issue Number
380 */
381 HWTEST_F(AllocHapTokenTest, AllocHapToken008, TestSize.Level1)
382 {
383 std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label;
384 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
385 DeleteTestToken();
386
387 const std::string invalidLabel (INVALID_LABEL_LEN, 'x');
388 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp03";
389 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = invalidLabel;
390 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
391 ASSERT_NE(INVALID_TOKENID, tokenID);
392
393 PermissionDef permDefResultBeta;
394 int ret = AccessTokenKit::GetDefPermission(
395 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta);
396 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
397 ret = AccessTokenKit::GetDefPermission(
398 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta);
399 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
400 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backUp;
401 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
402
403 DeleteTestToken();
404 }
405
406 /**
407 * @tc.name: AllocHapToken009
408 * @tc.desc: can alloc a tokenId with invalid permdef.
409 * @tc.type: FUNC
410 * @tc.require: Issue Number
411 */
412 HWTEST_F(AllocHapTokenTest, AllocHapToken009, TestSize.Level1)
413 {
414 std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description;
415 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
416 DeleteTestToken();
417
418 const std::string invalidDescription (INVALID_DESCRIPTION_LEN, 'x');
419
420 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp04";
421 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = invalidDescription;
422 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
423 ASSERT_NE(INVALID_TOKENID, tokenID);
424
425 PermissionDef permDefResultBeta;
426 int ret = AccessTokenKit::GetDefPermission(
427 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta);
428 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
429 ret = AccessTokenKit::GetDefPermission(
430 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta);
431 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
432
433 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = backUp;
434 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
435
436 DeleteTestToken();
437 }
438
ExistInVector(vector<unsigned int> array,unsigned int value)439 static bool ExistInVector(vector<unsigned int> array, unsigned int value)
440 {
441 vector<unsigned int>::iterator it = find(array.begin(), array.end(), value);
442 if (it != array.end()) {
443 return true;
444 } else {
445 return false;
446 }
447 }
448
449 /**
450 * @tc.name: AllocHapToken010
451 * @tc.desc: alloc and delete in a loop.
452 * @tc.type: FUNC
453 * @tc.require: Issue Number
454 */
455 HWTEST_F(AllocHapTokenTest, AllocHapToken010, TestSize.Level1)
456 {
457 int ret;
458 bool exist = false;
459 int allocFlag = 0;
460 int deleteFlag = 0;
461
462 DeleteTestToken();
463 vector<unsigned int> obj;
464 for (int i = 0; i < CYCLE_TIMES; i++) {
465 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
466
467 exist = ExistInVector(obj, tokenID);
468 if (exist) {
469 allocFlag = 1;
470 }
471 obj.push_back(tokenID);
472
473 ret = AccessTokenKit::DeleteToken(tokenID);
474 if (RET_SUCCESS != ret) {
475 deleteFlag = 1;
476 }
477 }
478 ASSERT_EQ(allocFlag, 0);
479 ASSERT_EQ(deleteFlag, 0);
480 }
481
482 /**
483 * @tc.name: AllocHapToken011
484 * @tc.desc: cannot alloc a tokenId with invalid appIDDesc.
485 * @tc.type: FUNC
486 * @tc.require: Issue Number
487 */
488 HWTEST_F(AllocHapTokenTest, AllocHapToken011, TestSize.Level1)
489 {
490 std::string invalidAppIDDesc (INVALID_APPIDDESC_LEN, 'x');
491 std::string backup = g_infoManagerTestInfoParms.appIDDesc;
492
493 DeleteTestToken();
494
495 g_infoManagerTestInfoParms.appIDDesc = invalidAppIDDesc;
496 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
497 ASSERT_EQ(INVALID_TOKENID, tokenID);
498 g_infoManagerTestInfoParms.appIDDesc = backup;
499 }
500
501 /**
502 * @tc.name: AllocHapToken012
503 * @tc.desc: cannot alloc a tokenId with invalid bundleName.
504 * @tc.type: FUNC
505 * @tc.require: Issue Number
506 */
507 HWTEST_F(AllocHapTokenTest, AllocHapToken012, TestSize.Level1)
508 {
509 std::string backup = g_infoManagerTestInfoParms.bundleName;
510
511 g_infoManagerTestInfoParms.bundleName = "";
512 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
513 ASSERT_EQ(INVALID_TOKENID, tokenID);
514 g_infoManagerTestInfoParms.bundleName = backup;
515 }
516
517 /**
518 * @tc.name: AllocHapToken013
519 * @tc.desc: cannot alloc a tokenId with invalid appIDDesc.
520 * @tc.type: FUNC
521 * @tc.require: Issue Number
522 */
523 HWTEST_F(AllocHapTokenTest, AllocHapToken013, TestSize.Level1)
524 {
525 std::string backup = g_infoManagerTestInfoParms.appIDDesc;
526
527 g_infoManagerTestInfoParms.appIDDesc = "";
528 AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
529 ASSERT_EQ(INVALID_TOKENID, tokenID);
530 g_infoManagerTestInfoParms.appIDDesc = backup;
531 }
532
533 /**
534 * @tc.name: AllocHapToken014
535 * @tc.desc: can alloc a tokenId with permList permissionName as "".
536 * @tc.type: FUNC
537 * @tc.require: Issue Number
538 */
539 HWTEST_F(AllocHapTokenTest, AllocHapToken014, TestSize.Level1)
540 {
541 std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
542
543 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "";
544 AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
545 PermissionDef permDefResultBeta;
546 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetDefPermission("", permDefResultBeta));
547 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backup;
548
549 DeleteTestToken();
550 }
551
552 /**
553 * @tc.name: AllocHapToken015
554 * @tc.desc: can alloc a tokenId with permList bundleName as "".
555 * @tc.type: FUNC
556 * @tc.require: Issue Number
557 */
558 HWTEST_F(AllocHapTokenTest, AllocHapToken015, TestSize.Level1)
559 {
560 std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName;
561 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
562
563 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = "";
564 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp05";
565 AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
566
567 PermissionDef permDefResultBeta;
568 int ret = AccessTokenKit::GetDefPermission(
569 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta);
570 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
571 ret = AccessTokenKit::GetDefPermission(
572 g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta);
573 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret);
574 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = backup;
575 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
576
577 DeleteTestToken();
578 }
579
580 /**
581 * @tc.name: AllocHapToken016
582 * @tc.desc: can alloc a tokenId with label as "".
583 * @tc.type: FUNC
584 * @tc.require: Issue Number
585 */
586 HWTEST_F(AllocHapTokenTest, AllocHapToken016, TestSize.Level1)
587 {
588 std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label;
589 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
590
591 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = "";
592 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp06";
593 AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
594
595 PermissionDef permDefResult;
596 int ret = AccessTokenKit::GetDefPermission(
597 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult);
598 ASSERT_EQ(ret, AccessTokenError::ERR_PERMISSION_NOT_EXIST);
599 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backup;
600 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
601
602 DeleteTestToken();
603 }
604
605 /**
606 * @tc.name: AllocHapToken017
607 * @tc.desc: cannot alloc a tokenId with invalid permdef.
608 * @tc.type: FUNC
609 * @tc.require: Issue Number
610 */
611 HWTEST_F(AllocHapTokenTest, AllocHapToken017, TestSize.Level1)
612 {
613 std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName;
614 std::string backupDec = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description;
615
616 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = "";
617 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp07";
618 AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams);
619
620 PermissionDef permDefResult;
621 int ret = AccessTokenKit::GetDefPermission(
622 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult);
623 ASSERT_EQ(ret, AccessTokenError::ERR_PERMISSION_NOT_EXIST);
624 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = backupDec;
625 g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission;
626
627 DeleteTestToken();
628 }
629
630 /**
631 * @tc.name: AllocHapToken018
632 * @tc.desc: alloc a tokenId with vaild dlptype.
633 * @tc.type: FUNC
634 * @tc.require: Issue Number
635 */
636 HWTEST_F(AllocHapTokenTest, AllocHapToken018, TestSize.Level1)
637 {
638 HapPolicyParams infoManagerTestPolicyPrams = {
639 .apl = APL_NORMAL,
640 .domain = "test.domain",
641 .permList = {},
642 .permStateList = {}
643 };
644 const HapInfoParams infoManagerTestInfoParms1 = {
645 .userID = 1,
646 .bundleName = "dlp_test1",
647 .instIndex = 0,
648 .dlpType = DLP_COMMON,
649 .appIDDesc = "test3",
650 .apiVersion = DEFAULT_API_VERSION
651 };
652 const HapInfoParams infoManagerTestInfoParms2 = {
653 .userID = 1,
654 .bundleName = "dlp_test2",
655 .instIndex = 1,
656 .dlpType = DLP_READ,
657 .appIDDesc = "test3",
658 .apiVersion = DEFAULT_API_VERSION
659 };
660 const HapInfoParams infoManagerTestInfoParms3 = {
661 .userID = 1,
662 .bundleName = "dlp_test3",
663 .instIndex = 2,
664 .dlpType = DLP_FULL_CONTROL,
665 .appIDDesc = "test3",
666 .apiVersion = DEFAULT_API_VERSION
667 };
668 GetDlpFlagTest(infoManagerTestInfoParms1, infoManagerTestPolicyPrams, DLP_COMMON);
669 GetDlpFlagTest(infoManagerTestInfoParms2, infoManagerTestPolicyPrams, DLP_READ);
670 GetDlpFlagTest(infoManagerTestInfoParms3, infoManagerTestPolicyPrams, DLP_FULL_CONTROL);
671 }
672
673 /**
674 * @tc.name: AllocHapToken019
675 * @tc.desc: cannot alloc a tokenId with invalid dlpType.
676 * @tc.type: FUNC
677 * @tc.require: Issue Number
678 */
679 HWTEST_F(AllocHapTokenTest, AllocHapToken019, TestSize.Level1)
680 {
681 AccessTokenIDEx tokenIdEx = {0};
682 HapPolicyParams infoManagerTestPolicyPrams = {
683 .apl = APL_NORMAL,
684 .domain = "test.domain",
685 .permList = {},
686 .permStateList = {}
687 };
688 HapInfoParams infoManagerTestInfoParms1 = {
689 .userID = 1,
690 .bundleName = "accesstoken_test",
691 .instIndex = 4,
692 .dlpType = INVALID_DLP_TYPE,
693 .appIDDesc = "test3",
694 .apiVersion = DEFAULT_API_VERSION
695 };
696
697 tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms1, infoManagerTestPolicyPrams);
698 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
699 }
700 } // namespace AccessToken
701 } // namespace Security
702 } // namespace OHOS