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 "accesstoken_service_ipc_interface_code.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_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms();
44 HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms();
45 HapPolicyParams g_infoManagerTestPolicyPrams = 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 }
70
SetUp()71 void GetHapTokenTest::SetUp()
72 {
73 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
74
75 HapInfoParams info = {
76 .userID = TEST_USER_ID,
77 .bundleName = TEST_BUNDLE_NAME,
78 .instIndex = 0,
79 .appIDDesc = "appIDDesc",
80 .apiVersion = DEFAULT_API_VERSION
81 };
82
83 HapPolicyParams policy = {
84 .apl = APL_NORMAL,
85 .domain = "domain"
86 };
87 TestCommon::TestPreparePermStateList(policy);
88
89 AccessTokenIDEx tokenIdEx = {0};
90 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(info, policy, tokenIdEx));
91 ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID);
92 }
93
TearDown()94 void GetHapTokenTest::TearDown()
95 {
96 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
97 TestCommon::DeleteTestHapToken(tokenID);
98 }
99
100 /**
101 * @tc.name: GetHapTokenIDFuncTest001
102 * @tc.desc: get hap tokenid.
103 * @tc.type: FUNC
104 * @tc.require: Issue Number
105 */
106 HWTEST_F(GetHapTokenTest, GetHapTokenIDFuncTest001, TestSize.Level1)
107 {
108 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDFuncTest001");
109
110 HapTokenInfo hapTokenInfoRes;
111 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
112 ASSERT_NE(INVALID_TOKENID, tokenID);
113
114 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
115 ASSERT_EQ(RET_SUCCESS, ret);
116 ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
117
118 ret = TestCommon::DeleteTestHapToken(tokenID);
119 ASSERT_EQ(RET_SUCCESS, ret);
120 }
121
122 /**
123 * @tc.name: GetHapTokenIDAbnormalTest001
124 * @tc.desc: cannot get hap tokenid with invalid userId.
125 * @tc.type: FUNC
126 * @tc.require: Issue Number
127 */
128 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest001, TestSize.Level1)
129 {
130 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest001");
131
132 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0);
133 ASSERT_EQ(INVALID_TOKENID, tokenID);
134 }
135
136 /**
137 * @tc.name: GetHapTokenIDAbnormalTest002
138 * @tc.desc: cannot get hap tokenid with invalid bundlename.
139 * @tc.type: FUNC
140 * @tc.require: Issue Number
141 */
142 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest002, TestSize.Level1)
143 {
144 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest002");
145
146 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "", 0);
147 ASSERT_EQ(INVALID_TOKENID, tokenID);
148
149 tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0);
150 ASSERT_EQ(INVALID_TOKENID, tokenID);
151 }
152
153 /**
154 * @tc.name: GetHapTokenIDAbnormalTest003
155 * @tc.desc: cannot get hap tokenid with invalid instIndex.
156 * @tc.type: FUNC
157 * @tc.require: Issue Number
158 */
159 HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest003, TestSize.Level1)
160 {
161 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest003");
162
163 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff);
164 ASSERT_EQ(INVALID_TOKENID, tokenID);
165 }
166
167 /**
168 * @tc.name: GetHapTokenIDExFuncTest001
169 * @tc.desc: get hap tokenid.
170 * @tc.type: FUNC
171 * @tc.require: issueI60F1M
172 */
173 HWTEST_F(GetHapTokenTest, GetHapTokenIDExFuncTest001, TestSize.Level1)
174 {
175 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExFuncTest001");
176
177 AccessTokenIDEx tokenIdEx;
178 TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx);
179 AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestSystemInfoParms.userID,
180 g_infoManagerTestSystemInfoParms.bundleName,
181 g_infoManagerTestSystemInfoParms.instIndex);
182
183 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
184 HapTokenInfo hapTokenInfoRes;
185 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
186 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
187 ASSERT_EQ(RET_SUCCESS, ret);
188 ASSERT_EQ(hapTokenInfoRes.bundleName, g_infoManagerTestSystemInfoParms.bundleName);
189 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
190 }
191
192 /**
193 * @tc.name: GetHapTokenIDExAbnormalTest001
194 * @tc.desc: cannot get hap tokenid with invalid userId.
195 * @tc.type: FUNC
196 * @tc.require: issueI60F1M
197 */
198 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest001, TestSize.Level1)
199 {
200 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest001");
201
202 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0);
203 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
204 }
205
206 /**
207 * @tc.name: GetHapTokenIDExAbnormalTest002
208 * @tc.desc: cannot get hap tokenid with invalid bundlename.
209 * @tc.type: FUNC
210 * @tc.require: issueI60F1M
211 */
212 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest002, TestSize.Level1)
213 {
214 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest002");
215
216 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "invalid bundlename", 0);
217 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
218 }
219
220 /**
221 * @tc.name: GetHapTokenIDExAbnormalTest003
222 * @tc.desc: cannot get hap tokenid with invalid instIndex.
223 * @tc.type: FUNC
224 * @tc.require: issueI60F1M
225 */
226 HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest003, TestSize.Level1)
227 {
228 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest003");
229
230 AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "", 0);
231 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
232
233 tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff);
234 ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx);
235 }
236
237 /**
238 * @tc.name: GetHapTokenInfoFuncTest001
239 * @tc.desc: get the token info and verify.
240 * @tc.type: FUNC
241 * @tc.require: Issue Number
242 */
243 HWTEST_F(GetHapTokenTest, GetHapTokenInfoFuncTest001, TestSize.Level0)
244 {
245 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFuncTest001");
246
247 HapTokenInfo hapTokenInfoRes;
248 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
249 ASSERT_NE(INVALID_TOKENID, tokenID);
250
251 int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes);
252 ASSERT_EQ(RET_SUCCESS, ret);
253
254 ASSERT_EQ(hapTokenInfoRes.userID, TEST_USER_ID);
255 ASSERT_EQ(hapTokenInfoRes.tokenID, tokenID);
256 ASSERT_EQ(hapTokenInfoRes.tokenAttr, static_cast<AccessTokenAttr>(0));
257 ASSERT_EQ(hapTokenInfoRes.instIndex, 0);
258
259 ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME);
260 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID));
261 }
262
263 /**
264 * @tc.name: GetHapTokenInfoAbnormalTest001
265 * @tc.desc: try to get the token info with invalid tokenId.
266 * @tc.type: FUNC
267 * @tc.require: Issue Number
268 */
269 HWTEST_F(GetHapTokenTest, GetHapTokenInfoAbnormalTest001, TestSize.Level0)
270 {
271 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoAbnormalTest001");
272
273 HapTokenInfo hapTokenInfoRes;
274 int ret = AccessTokenKit::GetHapTokenInfo(TEST_TOKENID_INVALID, hapTokenInfoRes);
275 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret);
276 }
277
278 /**
279 * @tc.name: GetHapTokenInfoExtensionFuncTest001
280 * @tc.desc: GetHapTokenInfoExt001.
281 * @tc.type: FUNC
282 * @tc.require: IAZTZD
283 */
284 HWTEST_F(GetHapTokenTest, GetHapTokenInfoExtensionFuncTest001, TestSize.Level1)
285 {
286 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoExtensionFuncTest001");
287 setuid(0);
288 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0);
289 ASSERT_NE(INVALID_TOKENID, tokenID);
290 HapTokenInfoExt hapTokenInfoExt;
291 int ret = AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapTokenInfoExt);
292 ASSERT_EQ(ret, 0);
293 ASSERT_EQ(TEST_BUNDLE_NAME, hapTokenInfoExt.baseInfo.bundleName);
294 ASSERT_EQ("appIDDesc", hapTokenInfoExt.appID);
295
296 ret = AccessTokenKit::GetHapTokenInfoExtension(INVALID_TOKENID, hapTokenInfoExt);
297 ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID);
298 }
299
300 /**
301 * @tc.name: IsSystemAppByFullTokenIDTest001
302 * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp true.
303 * @tc.type: FUNC
304 * @tc.require: issueI60F1M
305 */
306 HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest001, TestSize.Level1)
307 {
308 std::vector<std::string> reqPerm;
309 AccessTokenIDEx tokenIdEx = {0};
310 TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx);
311 ASSERT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
312
313 AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0);
314 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
315
316 UpdateHapInfoParams info;
317 info.appIDDesc = g_infoManagerTestSystemInfoParms.appIDDesc;
318 info.apiVersion = g_infoManagerTestSystemInfoParms.apiVersion;
319 info.isSystemApp = false;
320 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams));
321 tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0);
322 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
323
324 ASSERT_EQ(false, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
325 ASSERT_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.Level1)
335 {
336 AccessTokenIDEx tokenIdEx = {0};
337 TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx);
338 ASSERT_TRUE(TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
339
340 AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0);
341 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
342 UpdateHapInfoParams info;
343 info.appIDDesc = g_infoManagerTestNormalInfoParms.appIDDesc;
344 info.apiVersion = g_infoManagerTestNormalInfoParms.apiVersion;
345 info.isSystemApp = true;
346 ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams));
347 tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0);
348 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
349
350 ASSERT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx));
351 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
352 }
353
354 /**
355 * @tc.name: IsSystemAppByFullTokenIDTest003
356 * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false.
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest003, TestSize.Level1)
361 {
362 AccessTokenIDEx tokenIdEx = {0};
363 TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx);
364 AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0);
365 ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx);
366 bool res = AccessTokenKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx);
367 ASSERT_TRUE(res);
368 ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID));
369 }
370 } // namespace AccessToken
371 } // namespace Security
372 } // namespace OHOS