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 <cinttypes>
17 #include <cstdio>
18 
19 #include <gtest/gtest.h>
20 #include "ipc_skeleton.h"
21 #include "mmi_log.h"
22 #include "proto.h"
23 #include "tokenid_kit.h"
24 
25 #include "define_multimodal.h"
26 #include "permission_helper.h"
27 #include "uds_server.h"
28 
29 namespace OHOS {
30 namespace MMI {
31 namespace {
32 using namespace testing::ext;
33 const std::string INPUT_MONITORING = "ohos.permission.INPUT_MONITORING";
34 const std::string INPUT_INTERCEPTOR = "ohos.permission.INTERCEPT_INPUT_EVENT";
35 const std::string INPUT_DISPATCHCONTROL = "ohos.permission.INPUT_CONTROL_DISPATCHING";
36 } // namespace
37 
38 class PermissionHelperTest : public testing::Test {
39 public:
SetUpTestCase(void)40     static void SetUpTestCase(void) {}
TearDownTestCase(void)41     static void TearDownTestCase(void) {}
42 };
43 
44 /**
45  * @tc.name: PermissionHelperTest_GetTokenType
46  * @tc.desc: Test GetTokenType
47  * @tc.type: FUNC
48  * @tc.require:
49  */
50 HWTEST_F(PermissionHelperTest, PermissionHelperTest_GetTokenType, TestSize.Level1)
51 {
52     CALL_TEST_DEBUG;
53     uint32_t tokenId = 1;
54     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
55     tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
56     int32_t result1 = PER_HELPER->GetTokenType();
57     EXPECT_EQ(result1, 2);
58 
59     tokenId = 2;
60     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
61     int32_t result2 = PER_HELPER->GetTokenType();
62     EXPECT_EQ(result2, 2);
63 
64     tokenId = 3;
65     tokenType = OHOS::Security::AccessToken::TOKEN_SHELL;
66     int32_t result3 = PER_HELPER->GetTokenType();
67     EXPECT_EQ(result3, 2);
68 
69     tokenId = 4;
70     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
71     int32_t result4 = PER_HELPER->GetTokenType();
72     EXPECT_EQ(result4, 2);
73 }
74 
75 /**
76  * @tc.name: PermissionHelperTest_CheckDispatchControl_01
77  * @tc.desc: Test CheckDispatchControl
78  * @tc.type: FUNC
79  * @tc.require:
80  */
81 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckDispatchControl_01, TestSize.Level1)
82 {
83     CALL_TEST_DEBUG;
84     uint32_t tokenId = 1;
85     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
86     tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
87     bool result1 = PER_HELPER->CheckDispatchControl();
88     EXPECT_TRUE(result1);
89 
90     tokenId = 1;
91     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
92     bool result2 = PER_HELPER->CheckDispatchControl();
93     EXPECT_TRUE(result2);
94 
95     tokenId = 3;
96     tokenType = OHOS::Security::AccessToken::TOKEN_SHELL;
97     bool result3 = PER_HELPER->CheckDispatchControl();
98     EXPECT_TRUE(result3);
99 
100     tokenId = 4;
101     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
102     bool result4 = PER_HELPER->CheckDispatchControl();
103     EXPECT_TRUE(result4);
104 }
105 
106 /**
107  * @tc.name: PermissionHelperTest_CheckHapPermission_01
108  * @tc.desc: Test CheckHapPermission
109  * @tc.type: FUNC
110  * @tc.require:
111  */
112 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckHapPermission_01, TestSize.Level1)
113 {
114     CALL_TEST_DEBUG;
115     uint32_t tokenId = 3;
116     std::string permissionCode = "access";
117     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
118     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
119     bool result = PER_HELPER->CheckHapPermission(tokenId, permissionCode);
120     ASSERT_FALSE(result);
121 }
122 
123 /**
124  * @tc.name: PermissionHelperTest_CheckHapPermission_02
125  * @tc.desc: Test CheckHapPermission
126  * @tc.type: FUNC
127  * @tc.require:
128  */
129 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckHapPermission_02, TestSize.Level1)
130 {
131     CALL_TEST_DEBUG;
132     uint32_t tokenId = 5;
133     std::string permissionCode = "access denied";
134     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
135     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
136     bool result = PER_HELPER->CheckHapPermission(tokenId, permissionCode);
137     ASSERT_FALSE(result);
138 }
139 
140 /**
141  * @tc.name: PermissionHelperTest_CheckHapPermission_03
142  * @tc.desc: Test CheckHapPermission
143  * @tc.type: FUNC
144  * @tc.require:
145  */
146 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckHapPermission_03, TestSize.Level1)
147 {
148     CALL_TEST_DEBUG;
149     uint32_t tokenId = 1;
150     uint32_t required = 1;
151     OHOS::Security::AccessToken::HapTokenInfo findInfo;
152     int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenId, findInfo);
153     EXPECT_NE(ret, 0);
154     bool result = PER_HELPER->CheckHapPermission(tokenId, required);
155     ASSERT_FALSE(result);
156 }
157 
158 /**
159  * @tc.name: PermissionHelperTest_VerifySystemApp_01
160  * @tc.desc: Test VerifySystemApp
161  * @tc.type: FUNC
162  * @tc.require:
163  */
164 HWTEST_F(PermissionHelperTest, PermissionHelperTest_VerifySystemApp_01, TestSize.Level1)
165 {
166     CALL_TEST_DEBUG;
167     uint32_t callerToken = 3;
168     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken);
169     tokenType = OHOS::Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE;
170     bool result = PER_HELPER->VerifySystemApp();
171     EXPECT_TRUE(result);
172 }
173 
174 /**
175  * @tc.name: PermissionHelperTest_VerifySystemApp_02
176  * @tc.desc: Test VerifySystemApp
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(PermissionHelperTest, PermissionHelperTest_VerifySystemApp_02, TestSize.Level1)
181 {
182     CALL_TEST_DEBUG;
183     uint32_t callerToken = 5;
184     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken);
185     tokenType = OHOS::Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL;
186     bool result = PER_HELPER->VerifySystemApp();
187     EXPECT_TRUE(result);
188 }
189 
190 /**
191  * @tc.name: PermissionHelperTest_CheckPermission
192  * @tc.desc: Test CheckPermission
193  * @tc.type: FUNC
194  * @tc.require:
195  */
196 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckPermission, TestSize.Level1)
197 {
198     CALL_TEST_DEBUG;
199     uint32_t tokenId = 1;
200     uint32_t required = 2;
201     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
202     tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
203     bool result1 = PER_HELPER->CheckPermission(required);
204     EXPECT_TRUE(result1);
205 
206     tokenId = 2;
207     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
208     bool result2 = PER_HELPER->CheckPermission(required);
209     EXPECT_TRUE(result2);
210 
211     tokenId = 3;
212     tokenType = OHOS::Security::AccessToken::TOKEN_SHELL;
213     bool result3 = PER_HELPER->CheckPermission(required);
214     EXPECT_TRUE(result3);
215 
216     tokenId = 4;
217     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
218     bool result4 = PER_HELPER->CheckPermission(required);
219     EXPECT_TRUE(result4);
220 }
221 
222 /**
223  * @tc.name: PermissionHelperTest_CheckMonitor
224  * @tc.desc: Test CheckMonitor
225  * @tc.type: FUNC
226  * @tc.require:
227  */
228 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckMonitor, TestSize.Level1)
229 {
230     CALL_TEST_DEBUG;
231     uint32_t tokenId = 1;
232     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
233     tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
234     bool result1 = PER_HELPER->CheckMonitor();
235     EXPECT_TRUE(result1);
236 
237     tokenId = 2;
238     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
239     bool result2 = PER_HELPER->CheckMonitor();
240     EXPECT_TRUE(result2);
241 
242     tokenId = 3;
243     tokenType = OHOS::Security::AccessToken::TOKEN_SHELL;
244     bool result3 = PER_HELPER->CheckMonitor();
245     EXPECT_TRUE(result3);
246 
247     tokenId = 4;
248     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
249     bool result4 = PER_HELPER->CheckMonitor();
250     EXPECT_TRUE(result4);
251 }
252 
253 /**
254  * @tc.name: PermissionHelperTest_CheckInterceptor
255  * @tc.desc: Test CheckInterceptor
256  * @tc.type: FUNC
257  * @tc.require:
258  */
259 HWTEST_F(PermissionHelperTest, PermissionHelperTest_CheckInterceptor, TestSize.Level1)
260 {
261     CALL_TEST_DEBUG;
262     uint32_t tokenId = 1;
263     auto tokenType = OHOS::Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
264     tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
265     bool result1 = PER_HELPER->CheckInterceptor();
266     EXPECT_TRUE(result1);
267 
268     tokenId = 2;
269     tokenType = OHOS::Security::AccessToken::TOKEN_NATIVE;
270     bool result2 = PER_HELPER->CheckInterceptor();
271     EXPECT_TRUE(result2);
272 
273     tokenId = 3;
274     tokenType = OHOS::Security::AccessToken::TOKEN_SHELL;
275     bool result3 = PER_HELPER->CheckInterceptor();
276     EXPECT_TRUE(result3);
277 
278     tokenId = 4;
279     tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
280     bool result4 = PER_HELPER->CheckInterceptor();
281     EXPECT_TRUE(result4);
282 }
283 } // namespace MMI
284 } // namespace OHOS