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 "get_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 "iaccess_token_manager.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 uint64_t g_selfTokenId = 0;
37 static const std::string TEST_BUNDLE_NAME = "ohos";
38 static const unsigned int TEST_TOKENID_INVALID = 0;
39 static const int TEST_USER_ID = 0;
40 static constexpr int32_t DEFAULT_API_VERSION = 8;
41 static const int TEST_USER_ID_INVALID = -1;
42 static MockNativeToken* g_mock;
43 HapInfoParams g_testSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms();
44 HapInfoParams g_testNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms();
45 HapPolicyParams g_testPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams();
46 }
47
SetUpTestCase()48 void GetHapTokenTest::SetUpTestCase()
49 {
50 g_selfTokenId = GetSelfTokenID();
51 TestCommon::SetTestEvironment(g_selfTokenId);
52 g_mock = new (std::nothrow) MockNativeToken("foundation");
53
54 // clean up test cases
55 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
56 TestCommon::DeleteTestHapToken(tokenID);
57 }
58
TearDownTestCase()59 void GetHapTokenTest::TearDownTestCase()
60 {
61 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
62 TestCommon::DeleteTestHapToken(tokenID);
63
64 if (g_mock != nullptr) {
65 delete g_mock;
66 g_mock = nullptr;
67 }
68 SetSelfTokenID(g_selfTokenId);
69 TestCommon::ResetTestEvironment();
70 }
71
SetUp()72 void GetHapTokenTest::SetUp()
73 {
74 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
75
76 HapInfoParams info = {
77 .userID = TEST_USER_ID,
78 .bundleName = TEST_BUNDLE_NAME,
79 .instIndex = 0,
80 .appIDDesc = "appIDDesc",
81 .apiVersion = DEFAULT_API_VERSION
82 };
83
84 HapPolicyParams policy = {
85 .apl = APL_NORMAL,
86 .domain = "domain"
87 };
88 TestCommon::TestPreparePermStateList(policy);
89
90 AccessTokenIDEx tokenIdEx = {0};
91 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(info, policy, tokenIdEx));
92 EXPECT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
93 }
94
TearDown()95 void GetHapTokenTest::TearDown()
96 {
97 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
98 TestCommon::DeleteTestHapToken(tokenID);
99 }
100
101 /**
102 * @tc.name: GetHapTokenIDFuncTest001
103 * @tc.desc: get hap tokenid.
104 * @tc.type: FUNC
105 * @tc.require: Issue Number
106 */
107 HWTEST_F(GetHapTokenTest, GetHapTokenIDFuncTest001, TestSize.Level0)
108 {
109 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDFuncTest001");
110
111 HapTokenInfo hapTokenInfoRes;
112 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
113 ASSERT_NE(INVALID_TOKENID, tokenID);
114
115 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
116 ASSERT_EQ(RET_SUCCESS, ret);
117 EXPECT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
118
119 ret = TestCommon::DeleteTestHapToken(tokenID);
120 ASSERT_EQ(RET_SUCCESS, ret);
121 }
122
123 /**
124 * @tc.name: GetHapTokenIDAbnormalTest001
125 * @tc.desc: cannot get hap tokenid with invalid userId.
126 * @tc.type: FUNC
127 * @tc.require: Issue Number
128 */
129 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest001, TestSize.Level0)
130 {
131 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest001");
132
133 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0);
134 EXPECT_EQ(INVALID_TOKENID, tokenID);
135 }
136
137 /**
138 * @tc.name: GetHapTokenIDAbnormalTest002
139 * @tc.desc: cannot get hap tokenid with invalid bundlename.
140 * @tc.type: FUNC
141 * @tc.require: Issue Number
142 */
143 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest002, TestSize.Level0)
144 {
145 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest002");
146
147 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "", 0);
148 EXPECT_EQ(INVALID_TOKENID, tokenID);
149
150 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0);
151 EXPECT_EQ(INVALID_TOKENID, tokenID);
152 }
153
154 /**
155 * @tc.name: GetHapTokenIDAbnormalTest003
156 * @tc.desc: cannot get hap tokenid with invalid instIndex.
157 * @tc.type: FUNC
158 * @tc.require: Issue Number
159 */
160 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest003, TestSize.Level0)
161 {
162 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest003");
163
164 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff);
165 EXPECT_EQ(INVALID_TOKENID, tokenID);
166 }
167
168 /**
169 * @tc.name: GetHapTokenIDExFuncTest001
170 * @tc.desc: get hap tokenid.
171 * @tc.type: FUNC
172 * @tc.require: issueI60F1M
173 */
174 HWTEST_F(GetHapTokenTest, GetHapTokenIDExFuncTest001, TestSize.Level0)
175 {
176 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExFuncTest001");
177
178 AccessTokenIDEx tokenIdEx;
179 TestCommon::AllocTestHapToken(g_testSystemInfoParms, g_testPolicyPrams, tokenIdEx);
180 AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
181 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
182
183 EXPECT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
184 HapTokenInfo hapTokenInfoRes;
185 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
186 EXPECT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes));
187 EXPECT_EQ(hapTokenInfoRes.bundleName, g_testSystemInfoParms.bundleName);
188 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
189 }
190
191 /**
192 * @tc.name: GetHapTokenIDExAbnormalTest001
193 * @tc.desc: cannot get hap tokenid with invalid userId.
194 * @tc.type: FUNC
195 * @tc.require: issueI60F1M
196 */
197 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest001, TestSize.Level0)
198 {
199 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest001");
200
201 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0);
202 EXPECT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
203 }
204
205 /**
206 * @tc.name: GetHapTokenIDExAbnormalTest002
207 * @tc.desc: cannot get hap tokenid with invalid bundlename.
208 * @tc.type: FUNC
209 * @tc.require: issueI60F1M
210 */
211 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest002, TestSize.Level0)
212 {
213 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest002");
214
215 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "invalid bundlename", 0);
216 EXPECT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
217 }
218
219 /**
220 * @tc.name: GetHapTokenIDExAbnormalTest003
221 * @tc.desc: cannot get hap tokenid with invalid instIndex.
222 * @tc.type: FUNC
223 * @tc.require: issueI60F1M
224 */
225 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest003, TestSize.Level0)
226 {
227 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest003");
228
229 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "", 0);
230 EXPECT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
231
232 tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff);
233 EXPECT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
234 }
235
236 /**
237 * @tc.name: GetHapTokenInfoFuncTest001
238 * @tc.desc: get the token info and verify.
239 * @tc.type: FUNC
240 * @tc.require: Issue Number
241 */
242 HWTEST_F(GetHapTokenTest, GetHapTokenInfoFuncTest001, TestSize.Level0)
243 {
244 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFuncTest001");
245
246 HapTokenInfo hapTokenInfoRes;
247 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
248 ASSERT_NE(INVALID_TOKENID, tokenID);
249
250 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
251 ASSERT_EQ(RET_SUCCESS, ret);
252 EXPECT_EQ(hapTokenInfoRes.userID, TEST_USER_ID);
253 EXPECT_EQ(hapTokenInfoRes.tokenID, tokenID);
254 EXPECT_EQ(hapTokenInfoRes.tokenAttr, static_cast<AccessTokenAttr>(0));
255 EXPECT_EQ(hapTokenInfoRes.instIndex, 0);
256 EXPECT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
257 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
258 }
259
260 /**
261 * @tc.name: GetHapTokenInfoAbnormalTest001
262 * @tc.desc: try to get the token info with invalid tokenId.
263 * @tc.type: FUNC
264 * @tc.require: Issue Number
265 */
266 HWTEST_F(GetHapTokenTest, GetHapTokenInfoAbnormalTest001, TestSize.Level0)
267 {
268 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoAbnormalTest001");
269
270 HapTokenInfo hapTokenInfoRes;
271 int ret = AccessTokenKit::GetHapTokenInfo(TEST_TOKENID_INVALID, hapTokenInfoRes);
272 EXPECT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret);
273 }
274
275 /**
276 * @tc.name: GetHapTokenInfoExtensionFuncTest001
277 * @tc.desc: GetHapTokenInfoExt001.
278 * @tc.type: FUNC
279 * @tc.require: IAZTZD
280 */
281 HWTEST_F(GetHapTokenTest, GetHapTokenInfoExtensionFuncTest001, TestSize.Level0)
282 {
283 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoExtensionFuncTest001");
284 setuid(0);
285 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
286 ASSERT_NE(INVALID_TOKENID, tokenID);
287 HapTokenInfoExt hapTokenInfoExt;
288 int ret = AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapTokenInfoExt);
289 ASSERT_EQ(ret, 0);
290 EXPECT_EQ(TEST_BUNDLE_NAME, hapTokenInfoExt.baseInfo.bundleName);
291 EXPECT_EQ("appIDDesc", hapTokenInfoExt.appID);
292
293 ret = AccessTokenKit::GetHapTokenInfoExtension(INVALID_TOKENID, hapTokenInfoExt);
294 EXPECT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID);
295 }
296
297 /**
298 * @tc.name: IsSystemAppByFullTokenIDTest001
299 * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp true.
300 * @tc.type: FUNC
301 * @tc.require: issueI60F1M
302 */
303 HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest001, TestSize.Level0)
304 {
305 std::vector<std::string> reqPerm;
306 AccessTokenIDEx tokenIdEx = {0};
307 TestCommon::AllocTestHapToken(g_testSystemInfoParms, g_testPolicyPrams, tokenIdEx);
308 ASSERT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
309
310 AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
311 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
312
313 EXPECT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
314
315 UpdateHapInfoParams info;
316 info.appIDDesc = g_testSystemInfoParms.appIDDesc;
317 info.apiVersion = g_testSystemInfoParms.apiVersion;
318 info.isSystemApp = false;
319 EXPECT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyPrams));
320 tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
321 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
322 EXPECT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
323
324 EXPECT_EQ(false, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
325 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
326 }
327
328 /**
329 * @tc.name: IsSystemAppByFullTokenIDTest002
330 * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false.
331 * @tc.type: FUNC
332 * @tc.require: issueI60F1M
333 */
334 HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest002, TestSize.Level0)
335 {
336 AccessTokenIDEx tokenIdEx = {0};
337 TestCommon::AllocTestHapToken(g_testSystemInfoParms, g_testPolicyPrams, tokenIdEx);
338 EXPECT_TRUE(TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
339
340 AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
341 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
342 EXPECT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
343 UpdateHapInfoParams info;
344 info.appIDDesc = g_testNormalInfoParms.appIDDesc;
345 info.apiVersion = g_testNormalInfoParms.apiVersion;
346 info.isSystemApp = true;
347 EXPECT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyPrams));
348 tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
349 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
350 EXPECT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
351
352 EXPECT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
353 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
354 }
355
356 /**
357 * @tc.name: IsSystemAppByFullTokenIDTest003
358 * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false.
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest003, TestSize.Level0)
363 {
364 AccessTokenIDEx tokenIdEx = {0};
365 TestCommon::AllocTestHapToken(g_testSystemInfoParms, g_testPolicyPrams, tokenIdEx);
366 AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_testSystemInfoParms.userID,
367 g_testSystemInfoParms.bundleName, g_testSystemInfoParms.instIndex);
368 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
369 bool res = AccessTokenKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx);
370 ASSERT_TRUE(res);
371 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
372 }
373
374 /**
375 * @tc.name: GetHapTokenInfoWithRenderTest001
376 * @tc.desc: GetHapTokenInfo with render tokenID
377 * @tc.type: FUNC
378 * @tc.require: issue
379 */
380 HWTEST_F(GetHapTokenTest, GetHapTokenInfoWithRenderTest001, TestSize.Level0)
381 {
382 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
383 ASSERT_NE(INVALID_TOKENID, tokenID);
384
385 // get render token
386 uint64_t renderToken = AccessTokenKit::GetRenderTokenID(tokenID);
387 ASSERT_NE(renderToken, INVALID_TOKENID);
388 ASSERT_NE(renderToken, tokenID);
389
390 HapTokenInfo hapTokenInfoRes;
391 int ret = AccessTokenKit::GetHapTokenInfo(renderToken, hapTokenInfoRes);
392 EXPECT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, ret);
393
394 HapTokenInfoExt hapTokenInfoExt;
395 ret = AccessTokenKit::GetHapTokenInfoExtension(renderToken, hapTokenInfoExt);
396 EXPECT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, ret);
397 }
398 } // namespace AccessToken
399 } // namespace Security
400 } // namespace OHOS