1 /*
2 * Copyright (c) 2022-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 "UTTest_permission_manager.h"
17 #include "accesstoken_kit.h"
18 #include "nativetoken_kit.h"
19 #include "token_setproc.h"
20 #include "access_token.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace DistributedHardware {
SetUp()26 void PermissionManagerTest::SetUp()
27 {
28 const int32_t permsNum = 2;
29 const int32_t indexZero = 0;
30 const int32_t indexOne = 1;
31 uint64_t tokenId;
32 const char *perms[permsNum];
33 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
34 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
35 NativeTokenInfoParams infoInstance = {
36 .dcapsNum = 0,
37 .permsNum = permsNum,
38 .aclsNum = 0,
39 .dcaps = NULL,
40 .perms = perms,
41 .acls = NULL,
42 .processName = "dsoftbus_service",
43 .aplStr = "system_core",
44 };
45 tokenId = GetAccessTokenId(&infoInstance);
46 SetSelfTokenID(tokenId);
47 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
48 }
49 constexpr int32_t PAKAGE_NAME_SIZE_MAX = 256;
50
51 #define SYSTEM_SA_WHITE_LIST_NUM (4)
52 constexpr const static char SYSTEM_SA_WHITE_LIST[SYSTEM_SA_WHITE_LIST_NUM][PAKAGE_NAME_SIZE_MAX] = {
53 "Samgr_Networking",
54 "ohos.distributeddata.service",
55 "ohos.dslm",
56 "ohos.deviceprofile",
57 };
58
TearDown()59 void PermissionManagerTest::TearDown()
60 {
61 }
62
SetUpTestCase()63 void PermissionManagerTest::SetUpTestCase()
64 {
65 DMIPCSkeleton::dmIpcSkeleton_ = ipcSkeletonMock_;
66 DmAccessTokenKit::accessToken_ = accessTokenKitMock_;
67 }
68
TearDownTestCase()69 void PermissionManagerTest::TearDownTestCase()
70 {
71 DMIPCSkeleton::dmIpcSkeleton_ = nullptr;
72 ipcSkeletonMock_ = nullptr;
73 DmAccessTokenKit::accessToken_ = nullptr;
74 accessTokenKitMock_ = nullptr;
75 }
76
77 namespace {
78
79 /**
80 * @tc.name: PinAuthUi::CheckPermission_001
81 * @tc.desc: the return value is true
82 * @tc.type: FUNC
83 * @tc.require: AR000GHSJK
84 */
85 HWTEST_F(PermissionManagerTest, CheckPermission_001, testing::ext::TestSize.Level0)
86 {
87 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(0));
88 bool ret = PermissionManager::GetInstance().CheckPermission();
89 ASSERT_FALSE(ret);
90
91 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(10));
92 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_TYPE_BUTT));
93 ret = PermissionManager::GetInstance().CheckPermission();
94 ASSERT_TRUE(ret);
95
96 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(10));
97 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_HAP));
98 EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _))
99 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
100 ret = PermissionManager::GetInstance().CheckPermission();
101 ASSERT_FALSE(ret);
102
103 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(10));
104 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_HAP));
105 EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _))
106 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
107 ret = PermissionManager::GetInstance().CheckPermission();
108 ASSERT_TRUE(ret);
109 }
110
111 /**
112 * @tc.name: PinAuthUi::CheckWhiteListSystemSA_001
113 * @tc.desc: the return value is false
114 * @tc.type：FUNC
115 * @tc.require: AR000GHSJK
116 */
117 HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_001, testing::ext::TestSize.Level0)
118 {
119 std::string pkgName;
120 bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
121 ASSERT_EQ(ret, false);
122 pkgName = "pkgName";
123 ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
124 ASSERT_EQ(ret, false);
125 }
126
127 /**
128 * @tc.name: PinAuthUi::CheckWhiteListSystemSA_002
129 * @tc.desc: the return value is true
130 * @tc.type：FUNC
131 * @tc.require: AR000GHSJK
132 */
133 HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_002, testing::ext::TestSize.Level0)
134 {
135 std::string pkgName1(SYSTEM_SA_WHITE_LIST[0]);
136 bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName1);
137 ASSERT_EQ(ret, true);
138 std::string pkgName2(SYSTEM_SA_WHITE_LIST[1]);
139 ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName2);
140 ASSERT_EQ(ret, true);
141 std::string pkgName3(SYSTEM_SA_WHITE_LIST[2]);
142 ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName3);
143 ASSERT_EQ(ret, true);
144 std::string pkgName4(SYSTEM_SA_WHITE_LIST[3]);
145 ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName4);
146 ASSERT_EQ(ret, true);
147 }
148
149 HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_101, testing::ext::TestSize.Level0)
150 {
151 std::string pkgName = "pkgName";
152 bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
153 ASSERT_FALSE(ret);
154 }
155
156 HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_102, testing::ext::TestSize.Level0)
157 {
158 std::string pkgName = "ohos.dhardware";
159 bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
160 ASSERT_TRUE(ret);
161 }
162
163 HWTEST_F(PermissionManagerTest, CheckMonitorPermission_001, testing::ext::TestSize.Level0)
164 {
165 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(0));
166 bool ret = PermissionManager::GetInstance().CheckMonitorPermission();
167 ASSERT_FALSE(ret);
168
169 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
170 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_TYPE_BUTT));
171 ret = PermissionManager::GetInstance().CheckMonitorPermission();
172 ASSERT_TRUE(ret);
173
174 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
175 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE));
176 EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _))
177 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
178 ret = PermissionManager::GetInstance().CheckMonitorPermission();
179 ASSERT_FALSE(ret);
180
181 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
182 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE));
183 EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _))
184 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
185 ret = PermissionManager::GetInstance().CheckMonitorPermission();
186 ASSERT_TRUE(ret);
187 }
188
189 HWTEST_F(PermissionManagerTest, GetWhiteListSystemSA_001, testing::ext::TestSize.Level0)
190 {
191 auto ret = PermissionManager::GetInstance().GetWhiteListSystemSA();
192 ASSERT_FALSE(ret.empty());
193 }
194
195 HWTEST_F(PermissionManagerTest, CheckSystemSA_001, testing::ext::TestSize.Level0)
196 {
197 std::string pkgName = "pkgName";
198 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(0));
199 bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
200 ASSERT_FALSE(ret);
201
202 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
203 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE));
204 ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
205 ASSERT_TRUE(ret);
206
207 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1002));
208 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_TYPE_BUTT));
209 ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
210 ASSERT_FALSE(ret);
211 }
212
213 HWTEST_F(PermissionManagerTest, GetCallerProcessName_002, testing::ext::TestSize.Level0)
214 {
215 std::string processName;
216 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(0));
217 int32_t ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
218 ASSERT_EQ(ret, ERR_DM_FAILED);
219
220 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
221 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_HAP));
222 EXPECT_CALL(*accessTokenKitMock_, GetHapTokenInfo(_, _)).WillOnce(Return(ERR_DM_FAILED));
223 ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
224 ASSERT_EQ(ret, ERR_DM_FAILED);
225
226 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
227 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_HAP));
228 EXPECT_CALL(*accessTokenKitMock_, GetHapTokenInfo(_, _)).WillOnce(Return(DM_OK));
229 ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
230 ASSERT_EQ(ret, ERR_DM_FAILED);
231
232 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
233 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE));
234 EXPECT_CALL(*accessTokenKitMock_, GetNativeTokenInfo(_, _)).WillOnce(Return(ERR_DM_FAILED));
235 ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
236 ASSERT_EQ(ret, ERR_DM_FAILED);
237
238 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
239 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_NATIVE));
240 EXPECT_CALL(*accessTokenKitMock_, GetNativeTokenInfo(_, _)).WillOnce(Return(DM_OK));
241 ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
242 ASSERT_EQ(ret, DM_OK);
243
244 EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(1001));
245 EXPECT_CALL(*accessTokenKitMock_, GetTokenTypeFlag(_)).WillOnce(Return(ATokenTypeEnum::TOKEN_TYPE_BUTT));
246 ret = PermissionManager::GetInstance().GetCallerProcessName(processName);
247 ASSERT_EQ(ret, ERR_DM_FAILED);
248 }
249
250 HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnGetDeviceInfo_001, testing::ext::TestSize.Level0)
251 {
252 std::string processName = "";
253 auto ret = PermissionManager::GetInstance().CheckProcessNameValidOnGetDeviceInfo(processName);
254 ASSERT_FALSE(ret);
255
256 processName = "processName";
257 ret = PermissionManager::GetInstance().CheckProcessNameValidOnGetDeviceInfo(processName);
258 ASSERT_FALSE(ret);
259
260 processName = "gameservice_server";
261 ret = PermissionManager::GetInstance().CheckProcessNameValidOnGetDeviceInfo(processName);
262 ASSERT_TRUE(ret);
263 }
264 }
265 } // namespace DistributedHardware
266 } // namespace OHOS