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