1 /*
2 * Copyright (c) 2022 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 <gtest/gtest.h>
17
18 #include "ability_manager_privacy_client.h"
19 #include "ability_manager_privacy_proxy.h"
20 #include "accesstoken_kit.h"
21 #include "app_manager_privacy_client.h"
22 #include "app_manager_privacy_proxy.h"
23 #include "app_state_data.h"
24 #include "audio_manager_privacy_client.h"
25 #include "audio_manager_privacy_proxy.h"
26 #include "camera_manager_privacy_client.h"
27 #include "camera_manager_privacy_proxy.h"
28 #include "camera_service_callback_stub.h"
29 #include "token_setproc.h"
30 #include "window_manager_privacy_agent.h"
31 #define private public
32 #include "window_manager_privacy_client.h"
33 #undef private
34 #include "window_manager_privacy_proxy.h"
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Security {
39 namespace AccessToken {
40 class SensitiveManagerServiceTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47 static AccessTokenID g_selfTokenId = 0;
48 static PermissionStateFull g_testState1 = {
49 .permissionName = "ohos.permission.RUNNING_STATE_OBSERVER",
50 .isGeneral = true,
51 .resDeviceID = {"local"},
52 .grantStatus = {PermissionState::PERMISSION_GRANTED},
53 .grantFlags = {1}
54 };
55
56 static PermissionStateFull g_testState2 = {
57 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
58 .isGeneral = true,
59 .resDeviceID = {"local"},
60 .grantStatus = {PermissionState::PERMISSION_GRANTED},
61 .grantFlags = {1}
62 };
63
64 static PermissionStateFull g_testState3 = {
65 .permissionName = "ohos.permission.GET_RUNNING_INFO",
66 .isGeneral = true,
67 .resDeviceID = {"local"},
68 .grantStatus = {PermissionState::PERMISSION_GRANTED},
69 .grantFlags = {1}
70 };
71
72 static HapPolicyParams g_PolicyPrams1 = {
73 .apl = APL_NORMAL,
74 .domain = "test.domain.A",
75 .permList = {},
76 .permStateList = {g_testState1, g_testState2, g_testState3}
77 };
78
79 static HapInfoParams g_InfoParms1 = {
80 .userID = 1,
81 .bundleName = "ohos.privacy_test.bundleA",
82 .instIndex = 0,
83 .appIDDesc = "privacy_test.bundleA"
84 };
SetUpTestCase()85 void SensitiveManagerServiceTest::SetUpTestCase()
86 {
87 g_selfTokenId = GetSelfTokenID();
88 }
89
TearDownTestCase()90 void SensitiveManagerServiceTest::TearDownTestCase()
91 {
92 }
93
SetUp()94 void SensitiveManagerServiceTest::SetUp()
95 {
96 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
97 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID,
98 g_InfoParms1.bundleName,
99 g_InfoParms1.instIndex);
100 SetSelfTokenID(tokenId);
101 }
102
TearDown()103 void SensitiveManagerServiceTest::TearDown()
104 {
105 SetSelfTokenID(g_selfTokenId);
106 }
107
108 /*
109 * @tc.name: AudioManagerPrivacyTest001
110 * @tc.desc: test api function
111 * @tc.type: FUNC
112 * @tc.require: issueI5RWXF
113 */
114 HWTEST_F(SensitiveManagerServiceTest, AudioManagerPrivacyTest001, TestSize.Level1)
115 {
116 sptr<AudioRoutingManagerListenerStub> listener = new (std::nothrow) AudioRoutingManagerListenerStub();
117 ASSERT_NE(listener, nullptr);
118 ASSERT_NE(0, AudioManagerPrivacyClient::GetInstance().SetMicStateChangeCallback(nullptr));
119 ASSERT_EQ(0, AudioManagerPrivacyClient::GetInstance().SetMicStateChangeCallback(listener));
120 bool initMute = AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute();
121
122 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false);
123 EXPECT_EQ(false, AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute());
124
125 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(true);
126 EXPECT_EQ(true, AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute());
127
128 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false);
129 EXPECT_EQ(false, AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute());
130
131 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(initMute);
132 }
133
134 /*
135 * @tc.name: CameraManagerPrivacyTest001
136 * @tc.desc: test api function
137 * @tc.type: FUNC
138 * @tc.require: issueI5RWXF
139 */
140 HWTEST_F(SensitiveManagerServiceTest, CameraManagerPrivacyTest001, TestSize.Level1)
141 {
142 sptr<CameraServiceCallbackStub> listener = new (std::nothrow) CameraServiceCallbackStub();
143 ASSERT_NE(listener, nullptr);
144 ASSERT_NE(0, CameraManagerPrivacyClient::GetInstance().SetMuteCallback(nullptr));
145 ASSERT_EQ(0, CameraManagerPrivacyClient::GetInstance().SetMuteCallback(listener));
146 bool initMute = CameraManagerPrivacyClient::GetInstance().IsCameraMuted();
147
148 CameraManagerPrivacyClient::GetInstance().MuteCamera(false);
149 EXPECT_EQ(false, CameraManagerPrivacyClient::GetInstance().IsCameraMuted());
150
151 CameraManagerPrivacyClient::GetInstance().MuteCamera(true);
152 EXPECT_EQ(true, CameraManagerPrivacyClient::GetInstance().IsCameraMuted());
153
154 CameraManagerPrivacyClient::GetInstance().MuteCamera(false);
155 EXPECT_EQ(false, CameraManagerPrivacyClient::GetInstance().IsCameraMuted());
156
157 CameraManagerPrivacyClient::GetInstance().MuteCamera(initMute);
158 }
159
160 /*
161 * @tc.name: AppManagerPrivacyTest001
162 * @tc.desc: test api function
163 * @tc.type: FUNC
164 * @tc.require: issueI5RWXF
165 */
166 HWTEST_F(SensitiveManagerServiceTest, AppManagerPrivacyTest001, TestSize.Level1)
167 {
168 sptr<ApplicationStateObserverStub> listener = new(std::nothrow) ApplicationStateObserverStub();
169 ASSERT_NE(listener, nullptr);
170 ASSERT_NE(0, AppManagerPrivacyClient::GetInstance().RegisterApplicationStateObserver(nullptr));
171 ASSERT_EQ(0, AppManagerPrivacyClient::GetInstance().RegisterApplicationStateObserver(listener));
172
173 std::vector<AppStateData> list;
174 ASSERT_EQ(0, AppManagerPrivacyClient::GetInstance().GetForegroundApplications(list));
175
176 ASSERT_NE(0, AppManagerPrivacyClient::GetInstance().UnregisterApplicationStateObserver(nullptr));
177 ASSERT_EQ(0, AppManagerPrivacyClient::GetInstance().UnregisterApplicationStateObserver(listener));
178 }
179
180 /*
181 * @tc.name: AbilityManagerPrivacyTest001
182 * @tc.desc: test api function
183 * @tc.type: FUNC
184 * @tc.require: issueI5RWXF
185 */
186 HWTEST_F(SensitiveManagerServiceTest, AbilityManagerPrivacyTest001, TestSize.Level1)
187 {
188 const std::string bundleName = "com.ohos.permissionmanager";
189 const std::string abilityName = "com.ohos.permissionmanager.GlobalExtAbility";
190 const std::string resourceKey = "ohos.sensitive.resource";
191 std::string resource = "resource";
192 AAFwk::Want want;
193 want.SetElementName(bundleName, abilityName);
194 want.SetParam(resourceKey, resource);
195 ASSERT_NE(0, AbilityManagerPrivacyClient::GetInstance().StartAbility(want, nullptr));
196 }
197
198 /*
199 * @tc.name: WindowManagerPrivacyTest001
200 * @tc.desc: test api function
201 * @tc.type: FUNC
202 * @tc.require: issueI5RWXF
203 */
204 HWTEST_F(SensitiveManagerServiceTest, WindowManagerPrivacyTest001, TestSize.Level1)
205 {
206 sptr<WindowManagerPrivacyAgent> listener = new(std::nothrow) WindowManagerPrivacyAgent();
207 ASSERT_NE(listener, nullptr);
208 ASSERT_EQ(true, WindowManagerPrivacyClient::GetInstance().RegisterWindowManagerAgent(
209 WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_CAMERA_FLOAT, listener));
210 ASSERT_EQ(true, WindowManagerPrivacyClient::GetInstance().UnregisterWindowManagerAgent(
211 WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_CAMERA_FLOAT, listener));
212 }
213
214 class TestCallBack1 : public WindowManagerPrivacyAgent {
215 public:
216 TestCallBack1() = default;
217 virtual ~TestCallBack1() = default;
218
UpdateCameraFloatWindowStatus(uint32_t accessTokenId,bool isShowing)219 void UpdateCameraFloatWindowStatus(uint32_t accessTokenId, bool isShowing)
220 {
221 GTEST_LOG_(INFO) << "UpdateCameraFloatWindowStatus, accessTokenId is "
222 << accessTokenId << ", isShowing is " << isShowing << ".";
223 }
224 };
225
226 /**
227 * @tc.name: OnRemoteRequest001
228 * @tc.desc: WindowManagerPrivacyAgent::OnRemoteRequest function test
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest001, TestSize.Level1)
233 {
234 uint32_t accessTokenId = 123; // 123 is random input
235 bool isShowing = false;
236 TestCallBack1 callback;
237
238 OHOS::MessageParcel data;
239 OHOS::MessageParcel reply;
240 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
241
242 ASSERT_EQ(true, data.WriteInterfaceToken(IWindowManagerAgent::GetDescriptor()));
243 ASSERT_EQ(true, data.WriteUint32(accessTokenId));
244 ASSERT_EQ(true, data.WriteBool(isShowing));
245 uint32_t code = 10;
246 ASSERT_EQ(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgId default
247 }
248
249 /**
250 * @tc.name: OnRemoteRequest002
251 * @tc.desc: WindowManagerPrivacyAgent::OnRemoteRequest function test
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest002, TestSize.Level1)
256 {
257 uint32_t accessTokenId = 123; // 123 is random input
258 bool isShowing = false;
259 TestCallBack1 callback;
260
261 OHOS::MessageParcel data;
262 OHOS::MessageParcel reply;
263 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
264
265 ASSERT_EQ(true, data.WriteInterfaceToken(IWindowManagerAgent::GetDescriptor()));
266 ASSERT_EQ(true, data.WriteUint32(accessTokenId));
267 ASSERT_EQ(true, data.WriteBool(isShowing));
268 // descriptor flase + msgId = 5
269 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(
270 IWindowManagerAgent::WindowManagerAgentMsg::TRANS_ID_UPDATE_CAMERA_FLOAT), data, reply, option));
271 }
272
273 /**
274 * @tc.name: GetProxy001
275 * @tc.desc: WindowManagerPrivacyClient::GetProxy function test
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(SensitiveManagerServiceTest, GetProxy001, TestSize.Level1)
280 {
281 sptr<IWindowManager> proxy = WindowManagerPrivacyClient::GetInstance().proxy_; // backup
282 ASSERT_NE(nullptr, proxy);
283
284 WindowManagerPrivacyClient::GetInstance().proxy_ = nullptr;
285 WindowManagerPrivacyClient::GetInstance().GetProxy();
286 ASSERT_NE(nullptr, WindowManagerPrivacyClient::GetInstance().proxy_);
287
288 WindowManagerPrivacyClient::GetInstance().proxy_ = proxy; // recovery
289 }
290
291 class TestCallBack2 : public ApplicationStateObserverStub {
292 public:
293 TestCallBack2() = default;
294 virtual ~TestCallBack2() = default;
295
OnForegroundApplicationChanged(const AppStateData & appStateData)296 void OnForegroundApplicationChanged(const AppStateData &appStateData)
297 {
298 GTEST_LOG_(INFO) << "OnForegroundApplicationChanged, state is "
299 << appStateData.state;
300 }
301 };
302
303 /**
304 * @tc.name: OnRemoteRequest003
305 * @tc.desc: ApplicationStateObserverStub::OnRemoteRequest function test
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest003, TestSize.Level1)
310 {
311 AppStateData appData;
312 TestCallBack2 callback;
313
314 OHOS::MessageParcel data;
315 OHOS::MessageParcel reply;
316 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
317
318 ASSERT_EQ(true, data.WriteInterfaceToken(IApplicationStateObserver::GetDescriptor()));
319 ASSERT_EQ(true, data.WriteParcelable(&appData));
320 uint32_t code = 10;
321 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // code default
322 }
323
324 /**
325 * @tc.name: OnRemoteRequest004
326 * @tc.desc: ApplicationStateObserverStub::OnRemoteRequest function test
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest004, TestSize.Level1)
331 {
332 AppStateData appData;
333 TestCallBack2 callback;
334
335 OHOS::MessageParcel data;
336 OHOS::MessageParcel reply;
337 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
338
339 appData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
340 ASSERT_EQ(true, data.WriteInterfaceToken(IApplicationStateObserver::GetDescriptor()));
341 ASSERT_EQ(true, data.WriteParcelable(&appData));
342 // code not default + state = 3
343 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(
344 IApplicationStateObserver::Message::TRANSACT_ON_FOREGROUND_APPLICATION_CHANGED), data, reply, option));
345 }
346
347 /**
348 * @tc.name: OnRemoteRequest005
349 * @tc.desc: ApplicationStateObserverStub::OnRemoteRequest function test
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest005, TestSize.Level1)
354 {
355 AppStateData appData;
356 TestCallBack2 callback;
357
358 OHOS::MessageParcel data;
359 OHOS::MessageParcel reply;
360 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
361
362 appData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
363 ASSERT_EQ(true, data.WriteInterfaceToken(IApplicationStateObserver::GetDescriptor()));
364 ASSERT_EQ(true, data.WriteParcelable(&appData));
365 // code not default + state = 5
366 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(
367 IApplicationStateObserver::Message::TRANSACT_ON_FOREGROUND_APPLICATION_CHANGED), data, reply, option));
368 }
369
370 class TestCallBack3 : public CameraServiceCallbackStub {
371 public:
372 TestCallBack3() = default;
373 virtual ~TestCallBack3() = default;
374
OnCameraMute(bool muteMode)375 int32_t OnCameraMute(bool muteMode)
376 {
377 GTEST_LOG_(INFO) << "OnCameraMute, muteMode is " << muteMode;
378 return 0;
379 }
380 };
381
382 /**
383 * @tc.name: OnRemoteRequest006
384 * @tc.desc: CameraServiceCallbackStub::OnRemoteRequest function test
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest006, TestSize.Level1)
389 {
390 bool muteMode = false;
391 TestCallBack3 callback;
392
393 OHOS::MessageParcel data;
394 OHOS::MessageParcel reply;
395 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
396
397 ASSERT_EQ(true, data.WriteInterfaceToken(ICameraMuteServiceCallback::GetDescriptor()));
398 ASSERT_EQ(true, data.WriteBool(muteMode));
399 uint32_t code = 10;
400 ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // msgCode default
401 }
402
403 /**
404 * @tc.name: OnRemoteRequest007
405 * @tc.desc: CameraServiceCallbackStub::OnRemoteRequest function test
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(SensitiveManagerServiceTest, OnRemoteRequest007, TestSize.Level1)
410 {
411 bool muteMode = false;
412 TestCallBack3 callback;
413
414 OHOS::MessageParcel data;
415 OHOS::MessageParcel reply;
416 OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC);
417
418 ASSERT_EQ(true, data.WriteInterfaceToken(ICameraMuteServiceCallback::GetDescriptor()));
419 ASSERT_EQ(true, data.WriteBool(muteMode));
420 // msgId = 0
421 ASSERT_EQ(0, callback.OnRemoteRequest(static_cast<uint32_t>(
422 CameraMuteServiceCallbackRequestCode::CAMERA_CALLBACK_MUTE_MODE), data, reply, option));
423 }
424 } // namespace AccessToken
425 } // namespace Security
426 } // namespace OHOS
427