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_info_from_remote_test.h"
17 #include <thread>
18
19 #include "accesstoken_kit.h"
20 #include "accesstoken_common_log.h"
21 #include "access_token_error.h"
22 #include "nativetoken_kit.h"
23 #include "test_common.h"
24 #include "token_setproc.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::Security::AccessToken;
28
29 namespace {
30 static const std::string TEST_BUNDLE_NAME = "ohos";
31 static const std::string TEST_PKG_NAME = "com.softbus.test";
32 static uint64_t g_selfTokenId = 0;
33
34 HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms();
35 HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams();
36
37 HapTokenInfo g_baseInfo = {
38 .ver = 1,
39 .userID = 1,
40 .bundleName = "com.ohos.access_token",
41 .instIndex = 1,
42 .tokenID = 0x20100000,
43 .tokenAttr = 0
44 };
45
46 #ifdef TOKEN_SYNC_ENABLE
47 static const int32_t FAKE_SYNC_RET = 0xabcdef;
48 class TokenSyncCallbackImpl : public TokenSyncKitInterface {
49 public:
~TokenSyncCallbackImpl()50 ~TokenSyncCallbackImpl()
51 {}
52
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID) const53 int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override
54 {
55 LOGI(ATM_DOMAIN, ATM_TAG, "GetRemoteHapTokenInfo called.");
56 return FAKE_SYNC_RET;
57 };
58
DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const59 int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override
60 {
61 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteHapTokenInfo called.");
62 return FAKE_SYNC_RET;
63 };
64
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo) const65 int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override
66 {
67 LOGI(ATM_DOMAIN, ATM_TAG, "UpdateRemoteHapTokenInfo called.");
68 return FAKE_SYNC_RET;
69 };
70 };
71 #endif
72 }
73
SetUpTestCase()74 void GetHapTokenInfoFromRemoteTest::SetUpTestCase()
75 {
76 g_selfTokenId = GetSelfTokenID();
77 TestCommon::SetTestEvironment(g_selfTokenId);
78
79 // make test case clean
80 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID,
81 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
82 TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
83
84 #ifdef TOKEN_SYNC_ENABLE
85 {
86 MockNativeToken mock("foundation");
87 std::shared_ptr<TestDmInitCallback> ptrDmInitCallback = std::make_shared<TestDmInitCallback>();
88 int32_t res =
89 DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback);
90 ASSERT_EQ(res, RET_SUCCESS);
91 }
92 #endif
93 }
94
TearDownTestCase()95 void GetHapTokenInfoFromRemoteTest::TearDownTestCase()
96 {
97 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID,
98 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
99 TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
100
101 #ifdef TOKEN_SYNC_ENABLE
102 {
103 MockNativeToken mock("foundation");
104 int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME);
105 ASSERT_EQ(res, RET_SUCCESS);
106 }
107 #endif
108 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
109 TestCommon::ResetTestEvironment();
110 }
111
SetUp()112 void GetHapTokenInfoFromRemoteTest::SetUp()
113 {
114 #ifdef TOKEN_SYNC_ENABLE
115 MockNativeToken mock("foundation");
116 DistributedHardware::DmDeviceInfo deviceInfo;
117 int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo);
118 ASSERT_EQ(res, RET_SUCCESS);
119
120 networkId_ = std::string(deviceInfo.networkId);
121 ASSERT_NE(networkId_, "");
122
123 res = DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TEST_PKG_NAME, networkId_, udid_);
124 ASSERT_EQ(res, RET_SUCCESS);
125 ASSERT_NE(udid_, "");
126 #endif
127
128 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
129 }
130
TearDown()131 void GetHapTokenInfoFromRemoteTest::TearDown()
132 {
133 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
134 udid_.clear();
135 networkId_.clear();
136 }
137
138 #ifdef TOKEN_SYNC_ENABLE
139 /**
140 * @tc.name: GetHapTokenInfoFromRemoteFuncTest001
141 * @tc.desc: get normal local tokenInfo
142 * @tc.type: FUNC
143 * @tc.require:issue I5R4UF
144 */
145 HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest001, TestSize.Level0)
146 {
147 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteFuncTest001 start.");
148
149 AccessTokenIDEx tokenIdEx = {0};
150 ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(
151 g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx));
152 AccessTokenID localTokenID = tokenIdEx.tokenIdExStruct.tokenID;
153
154 MockNativeToken mock("token_sync_service");
155
156 HapTokenInfoForSync infoSync;
157 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(localTokenID, infoSync);
158 EXPECT_EQ(ret, RET_SUCCESS);
159 EXPECT_EQ(infoSync.permStateList.size(), static_cast<uint32_t>(2));
160
161 EXPECT_EQ(infoSync.permStateList[0].permissionName, g_infoManagerTestPolicyPrams.permStateList[0].permissionName);
162
163 EXPECT_EQ(infoSync.permStateList[1].permissionName, g_infoManagerTestPolicyPrams.permStateList[1].permissionName);
164
165 EXPECT_EQ(infoSync.baseInfo.bundleName, g_infoManagerTestInfoParms.bundleName);
166 EXPECT_EQ(infoSync.baseInfo.userID, g_infoManagerTestInfoParms.userID);
167 EXPECT_EQ(infoSync.baseInfo.instIndex, g_infoManagerTestInfoParms.instIndex);
168 EXPECT_EQ(infoSync.baseInfo.ver, 1);
169 EXPECT_EQ(infoSync.baseInfo.tokenID, localTokenID);
170 EXPECT_EQ(infoSync.baseInfo.tokenAttr, 0);
171
172 EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(localTokenID));
173 }
174
175 /**
176 * @tc.name: GetHapTokenInfoFromRemoteFuncTest002
177 * @tc.desc: get remote mapping tokenInfo
178 * @tc.type: FUNC
179 * @tc.require:issue I5R4UF
180 */
181 HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest002, TestSize.Level0)
182 {
183 MockNativeToken mock("token_sync_service");
184 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteFuncTest002 start.");
185 std::string deviceID2 = udid_;
186 AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
187 PermissionStatus infoManagerTestState2 = {
188 .permissionName = "ohos.permission.test1",
189 .grantStatus = PermissionState::PERMISSION_GRANTED,
190 .grantFlag = PermissionFlag::PERMISSION_USER_SET};
191 std::vector<PermissionStatus> permStateList2;
192 permStateList2.emplace_back(infoManagerTestState2);
193
194 HapTokenInfoForSync remoteTokenInfo2 = {
195 .baseInfo = g_baseInfo,
196 .permStateList = permStateList2
197 };
198
199 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
200 ASSERT_EQ(ret, RET_SUCCESS);
201
202 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000);
203 ASSERT_NE(mapID, 0);
204
205 HapTokenInfoForSync infoSync;
206 ret = AccessTokenKit::GetHapTokenInfoFromRemote(mapID, infoSync);
207 ASSERT_NE(ret, RET_SUCCESS);
208
209 AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000);
210 }
211
212 /**
213 * @tc.name: GetHapTokenInfoFromRemoteAbnormalTest001
214 * @tc.desc: get wrong tokenInfo
215 * @tc.type: FUNC
216 * @tc.require:issue I5R4UF
217 */
218 HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteAbnormalTest001, TestSize.Level0)
219 {
220 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteAbnormalTest001 start.");
221 HapTokenInfoForSync infoSync;
222 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(0, infoSync);
223 ASSERT_NE(ret, RET_SUCCESS);
224 }
225
226 /**
227 * @tc.name: GetHapTokenInfoFromRemoteAbnormalTest002
228 * @tc.desc: GetHapTokenInfoFromRemote with no permission
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteAbnormalTest002, TestSize.Level0)
233 {
234 LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteAbnormalTest002 start.");
235 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
236 AccessTokenID tokenId = 123;
237 HapTokenInfoForSync hapSync;
238 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetHapTokenInfoFromRemote(tokenId, hapSync));
239 }
240 #endif