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 <cstdint>
17 #include <gtest/gtest.h>
18 #include <string>
19
20 #include "access_token.h"
21 #include "accesstoken_kit.h"
22 #include "active_change_response_info.h"
23 #include "audio_manager_adapter.h"
24 #include "constant.h"
25 #include "data_translator.h"
26 #include "permission_record.h"
27 #define private public
28 #include "active_status_callback_manager.h"
29 #include "libraryloader.h"
30 #include "permission_record_manager.h"
31 #include "permission_used_record_db.h"
32 #include "privacy_manager_service.h"
33 #include "privacy_manager_proxy_death_param.h"
34 #include "proxy_death_callback_stub.h"
35 #undef private
36 #include "parameter.h"
37 #include "perm_active_status_change_callback_stub.h"
38 #include "privacy_error.h"
39 #include "privacy_field_const.h"
40 #include "privacy_kit.h"
41 #include "state_change_callback.h"
42 #include "time_util.h"
43 #include "token_setproc.h"
44
45 using namespace testing;
46 using namespace testing::ext;
47 using namespace OHOS;
48
49 namespace OHOS {
50 namespace Security {
51 namespace AccessToken {
52 namespace {
53 static int32_t PID = -1;
54 static int32_t TEST_PID_1 = 1;
55 static int32_t TEST_PID_2 = 2;
56 static int32_t TEST_PID_3 = 3;
57 static constexpr int32_t CALLER_PID = 11;
58 static constexpr int32_t CALLER_PID2 = 12;
59 static AccessTokenID g_selfTokenId = 0;
60 static AccessTokenID g_nativeToken = 0;
61 static bool g_isMicEdmMute = false;
62 static bool g_isMicMixMute = false;
63 static constexpr int32_t TEST_USER_ID_10 = 10;
64 static constexpr int32_t TEST_INVALID_USER_ID = -1;
65 static constexpr int32_t TEST_INVALID_USER_ID_20000 = 20000;
66 static constexpr uint32_t MAX_CALLBACK_SIZE = 1024;
67 static constexpr uint32_t RANDOM_TOKENID = 123;
68 static constexpr int32_t FIRST_INDEX = 0;
69 static const int32_t NORMAL_TYPE_ADD_VALUE = 1;
70 static const int32_t PICKER_TYPE_ADD_VALUE = 2;
71 static const int32_t SEC_COMPONENT_TYPE_ADD_VALUE = 4;
72 static const int32_t VALUE_MAX_LEN = 32;
73 static const char* EDM_MIC_MUTE_KEY = "persist.edm.mic_disable";
74 static PermissionStateFull g_testState1 = {
75 .permissionName = "ohos.permission.CAMERA",
76 .isGeneral = true,
77 .resDeviceID = {"local"},
78 .grantStatus = {PermissionState::PERMISSION_GRANTED},
79 .grantFlags = {1}
80 };
81
82 static PermissionStateFull g_testState2 = {
83 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
84 .isGeneral = true,
85 .resDeviceID = {"local"},
86 .grantStatus = {PermissionState::PERMISSION_GRANTED},
87 .grantFlags = {1}
88 };
89
90 static PermissionStateFull g_testState3 = {
91 .permissionName = "ohos.permission.MANAGE_AUDIO_CONFIG",
92 .isGeneral = true,
93 .resDeviceID = {"local"},
94 .grantStatus = {PermissionState::PERMISSION_GRANTED},
95 .grantFlags = {1}
96 };
97
98 static HapPolicyParams g_PolicyPrams1 = {
99 .apl = APL_NORMAL,
100 .domain = "test.domain.A",
101 .permList = {},
102 .permStateList = {g_testState1, g_testState2, g_testState3}
103 };
104
105 static HapInfoParams g_InfoParms1 = {
106 .userID = 1,
107 .bundleName = "ohos.privacy_test.bundleA",
108 .instIndex = 0,
109 .appIDDesc = "privacy_test.bundleA"
110 };
111
112 static HapPolicyParams g_PolicyPrams2 = {
113 .apl = APL_NORMAL,
114 .domain = "test.domain.B",
115 .permList = {},
116 .permStateList = {g_testState1}
117 };
118
119 static HapInfoParams g_InfoParms2 = {
120 .userID = 1,
121 .bundleName = "ohos.privacy_test.bundleB",
122 .instIndex = 0,
123 .appIDDesc = "privacy_test.bundleB"
124 };
125 }
126 class PermissionRecordManagerTest : public testing::Test {
127 public:
128 static void SetUpTestCase();
129
130 static void TearDownTestCase();
131
132 void SetUp();
133
134 void TearDown();
135
136 std::shared_ptr<PrivacyAppStateObserver> appStateObserver_ = nullptr;
137 };
138
SetUpTestCase()139 void PermissionRecordManagerTest::SetUpTestCase()
140 {
141 DelayedSingleton<PrivacyManagerService>::GetInstance()->Initialize();
142 PermissionRecordManager::GetInstance().Init();
143
144 g_selfTokenId = GetSelfTokenID();
145 g_nativeToken = AccessTokenKit::GetNativeTokenId("privacy_service");
146 g_isMicEdmMute = PermissionRecordManager::GetInstance().isMicEdmMute_;
147 g_isMicMixMute = PermissionRecordManager::GetInstance().isMicMixMute_;
148 PermissionRecordManager::GetInstance().isMicEdmMute_ = false;
149 PermissionRecordManager::GetInstance().isMicMixMute_ = false;
150 }
151
TearDownTestCase()152 void PermissionRecordManagerTest::TearDownTestCase()
153 {
154 PermissionRecordManager::GetInstance().isMicEdmMute_ = g_isMicEdmMute;
155 PermissionRecordManager::GetInstance().isMicMixMute_ = g_isMicMixMute;
156 }
157
SetUp()158 void PermissionRecordManagerTest::SetUp()
159 {
160 PermissionRecordManager::GetInstance().Init();
161 PermissionRecordManager::GetInstance().Register();
162
163 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
164 AccessTokenKit::AllocHapToken(g_InfoParms2, g_PolicyPrams2);
165 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
166 RANDOM_TOKENID);
167 if (appStateObserver_ != nullptr) {
168 return;
169 }
170 appStateObserver_ = std::make_shared<PrivacyAppStateObserver>();
171 }
172
TearDown()173 void PermissionRecordManagerTest::TearDown()
174 {
175 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
176 g_InfoParms1.instIndex);
177 AccessTokenKit::DeleteToken(tokenId);
178 PrivacyKit::RemovePermissionUsedRecords(tokenId);
179 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
180 g_InfoParms2.instIndex);
181 AccessTokenKit::DeleteToken(tokenId);
182 PrivacyKit::RemovePermissionUsedRecords(tokenId);
183 appStateObserver_ = nullptr;
184 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
185 }
186
187 class PermissionRecordManagerTestCb1 : public StateCustomizedCbk {
188 public:
PermissionRecordManagerTestCb1()189 PermissionRecordManagerTestCb1()
190 {}
191
~PermissionRecordManagerTestCb1()192 ~PermissionRecordManagerTestCb1()
193 {}
194
StateChangeNotify(AccessTokenID tokenId,bool isShow)195 void StateChangeNotify(AccessTokenID tokenId, bool isShow)
196 {
197 GTEST_LOG_(INFO) << "PermissionRecordManagerTestCb1 isShow" << isShow;
198 isShow_ = isShow;
199 }
200
Stop()201 void Stop()
202 {}
203
204 bool isShow_ = true;
205 };
206
MakeInfo(AccessTokenID tokenId,int32_t pid,const std::string & permission,PermissionUsedType type=PermissionUsedType::NORMAL_TYPE)207 static PermissionUsedTypeInfo MakeInfo(AccessTokenID tokenId, int32_t pid, const std::string &permission,
208 PermissionUsedType type = PermissionUsedType::NORMAL_TYPE)
209 {
210 PermissionUsedTypeInfo info = {
211 .tokenId = tokenId,
212 .pid = pid,
213 .permissionName = permission,
214 .type = type
215 };
216 return info;
217 }
218
219 /**
220 * @tc.name: RegisterPermActiveStatusCallback001
221 * @tc.desc: RegisterPermActiveStatusCallback with invalid parameter.
222 * @tc.type: FUNC
223 * @tc.require: issueI5RWX8
224 */
225 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback001, TestSize.Level1)
226 {
227 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
228 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
229 GetSelfTokenID(), permList, nullptr));
230 }
231
232
233 class PermActiveStatusChangeCallback : public PermActiveStatusChangeCallbackStub {
234 public:
235 PermActiveStatusChangeCallback() = default;
236 virtual ~PermActiveStatusChangeCallback() = default;
237
AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient> & deathRecipient)238 bool AddDeathRecipient(const sptr<IRemoteObject::DeathRecipient>& deathRecipient) override
239 {
240 return true;
241 }
242
ActiveStatusChangeCallback(ActiveChangeResponse & result)243 void ActiveStatusChangeCallback(ActiveChangeResponse& result) override
244 {
245 type_ = result.type;
246 GTEST_LOG_(INFO) << "ActiveStatusChange tokenid " << result.tokenID <<
247 ", permission " << result.permissionName << ", type " << result.type;
248 }
249
250 ActiveChangeType type_ = PERM_INACTIVE;
251 };
252
253 /**
254 * @tc.name: RegisterPermActiveStatusCallback002
255 * @tc.desc: RegisterPermActiveStatusCallback with exceed limitation.
256 * @tc.type: FUNC
257 * @tc.require: issueI5RWX8
258 */
259 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback002, TestSize.Level1)
260 {
261 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
262 std::vector<sptr<PermActiveStatusChangeCallback>> callbacks;
263
264 for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
265 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
266 ASSERT_NE(nullptr, callback);
267 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
268 GetSelfTokenID(), permList, callback->AsObject()));
269 callbacks.emplace_back(callback);
270 }
271
272 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
273 ASSERT_NE(nullptr, callback);
274 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
275 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
276 GetSelfTokenID(), permList, callback->AsObject()));
277
278 for (size_t i = 0; i < callbacks.size(); ++i) {
279 ASSERT_EQ(RET_SUCCESS,
280 PermissionRecordManager::GetInstance().UnRegisterPermActiveStatusCallback(callbacks[i]->AsObject()));
281 }
282 }
283
284 /**
285 * @tc.name: UnRegisterPermActiveStatusCallback001
286 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid parameter.
287 * @tc.type: FUNC
288 * @tc.require: issueI5RWX8
289 */
290 HWTEST_F(PermissionRecordManagerTest, UnRegisterPermActiveStatusCallback001, TestSize.Level1)
291 {
292 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
293 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
294 GetSelfTokenID(), permList, nullptr));
295 }
296
297 /*
298 * @tc.name: StartUsingPermissionTest001
299 * @tc.desc: StartUsingPermission function test with invaild tokenId.
300 * @tc.type: FUNC
301 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
302 */
303 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level1)
304 {
305 std::string permissionName = "ohos.permission.CAMERA";
306 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
307 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
308 ASSERT_NE(nullptr, callbackPtr);
309 ASSERT_NE(nullptr, callbackWrap);
310 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
311 g_InfoParms1.instIndex);
312 ASSERT_NE(INVALID_TOKENID, tokenId);
313 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
314 MakeInfo(0, PID, permissionName), callbackWrap->AsObject(), CALLER_PID));
315 }
316
317 /*
318 * @tc.name: StartUsingPermissionTest002
319 * @tc.desc: StartUsingPermission function test with invaild permissionName.
320 * @tc.type: FUNC
321 * @tc.require: issueI5RWXF
322 */
323 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest002, TestSize.Level1)
324 {
325 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
326
327 auto callbackPtr = std::make_shared<PermissionRecordManagerTestCb1>();
328 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
329 ASSERT_NE(nullptr, callbackPtr);
330 ASSERT_NE(nullptr, callbackWrap);
331 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
332 g_InfoParms1.instIndex);
333 ASSERT_NE(INVALID_TOKENID, tokenId);
334 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
335 MakeInfo(tokenId, PID, "ohos.permission.LOCATION"), callbackWrap->AsObject(), CALLER_PID));
336
337 // tokenId invaild
338 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
339 MakeInfo(g_nativeToken, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
340
341 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
342 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
343 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
344 PermissionRecordManager::GetInstance().StartUsingPermission(
345 MakeInfo(tokenId, PID, "ohos.permission.CAMERA"), nullptr, CALLER_PID));
346
347 ASSERT_EQ(Constant::SUCCESS,
348 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.CAMERA", CALLER_PID));
349 }
350
351 /*
352 * @tc.name: StartUsingPermissionTest003
353 * @tc.desc:
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest003, TestSize.Level1)
358 {
359 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
360
361 char value[VALUE_MAX_LEN] = {0};
362 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
363 GTEST_LOG_(INFO) << "value:" << value;
364
365 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
366 SetParameter(EDM_MIC_MUTE_KEY, "true");
367
368 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
369 g_InfoParms1.instIndex);
370 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
371 std::string permissionName = "ohos.permission.MICROPHONE";
372 ASSERT_EQ(PrivacyError::ERR_EDM_POLICY_CHECK_FAILED,
373 PermissionRecordManager::GetInstance().StartUsingPermission(
374 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
375 std::string str = isMute ? "true" : "false";
376 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
377 }
378
379 /*
380 * @tc.name: StartUsingPermissionTest004
381 * @tc.desc:
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest004, TestSize.Level1)
386 {
387 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
388
389 char value[VALUE_MAX_LEN] = {0};
390 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
391 GTEST_LOG_(INFO) << "value:" << value;
392
393 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
394 SetParameter(EDM_MIC_MUTE_KEY, "false");
395
396 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
397 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
398
399 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
400 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
401 ASSERT_NE(nullptr, callback);
402 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
403 GetSelfTokenID(), permList, callback->AsObject()));
404
405 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
406 g_InfoParms1.instIndex);
407 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
408 std::string permissionName = "ohos.permission.READ_MEDIA";
409 ASSERT_EQ(RET_SUCCESS,
410 PermissionRecordManager::GetInstance().StartUsingPermission(
411 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
412
413 usleep(1000000); // 1000000us = 1s
414 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
415 ASSERT_EQ(Constant::SUCCESS,
416 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
417 std::string str = isMute ? "true" : "false";
418 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
419 }
420
421 /*
422 * @tc.name: StartUsingPermissionTest005
423 * @tc.desc:
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest005, TestSize.Level1)
428 {
429 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
430
431 char value[VALUE_MAX_LEN] = {0};
432 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
433 GTEST_LOG_(INFO) << "value:" << value;
434
435 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
436 SetParameter(EDM_MIC_MUTE_KEY, "false");
437
438 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
439 RANDOM_TOKENID);
440 std::vector<std::string> permList = {"ohos.permission.READ_MEDIA"};
441 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
442 ASSERT_NE(nullptr, callback);
443 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
444 GetSelfTokenID(), permList, callback->AsObject()));
445
446 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
447 g_InfoParms1.instIndex);
448 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
449 std::string permissionName = "ohos.permission.READ_MEDIA";
450 ASSERT_EQ(RET_SUCCESS,
451 PermissionRecordManager::GetInstance().StartUsingPermission(
452 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
453
454 usleep(1000000); // 1000000us = 1s
455 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
456 ASSERT_EQ(Constant::SUCCESS,
457 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
458
459 std::string str = isMute ? "true" : "false";
460 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
461 }
462
463 /*
464 * @tc.name: StartUsingPermissionTest006
465 * @tc.desc:
466 * @tc.type: FUNC
467 * @tc.require:
468 */
469 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest006, TestSize.Level1)
470 {
471 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
472
473 char value[VALUE_MAX_LEN] = {0};
474 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
475 GTEST_LOG_(INFO) << "value:" << value;
476
477 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
478 SetParameter(EDM_MIC_MUTE_KEY, "true");
479
480 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
481 RANDOM_TOKENID);
482 std::vector<std::string> permList = {"ohos.permission.LOCATION"};
483 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
484 ASSERT_NE(nullptr, callback);
485 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
486 GetSelfTokenID(), permList, callback->AsObject()));
487
488 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
489 g_InfoParms1.instIndex);
490 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
491 std::string permissionName = "ohos.permission.LOCATION";
492 ASSERT_EQ(RET_SUCCESS,
493 PermissionRecordManager::GetInstance().StartUsingPermission(
494 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
495
496 usleep(500000); // 500000us = 0.5s
497 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
498 ASSERT_EQ(Constant::SUCCESS,
499 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, permissionName, CALLER_PID));
500
501 std::string str = isMute ? "true" : "false";
502 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
503 }
504
505 /*
506 * @tc.name: StartUsingPermissionTest007
507 * @tc.desc: PermissionRecordManager::StartUsingPermission function test
508 * @tc.type: FUNC
509 * @tc.require:
510 */
511 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest007, TestSize.Level1)
512 {
513 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
514 g_InfoParms1.instIndex);
515 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
516
517 // tokenId invaild
518 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
519 MakeInfo(g_nativeToken, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
520
521 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
522 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
523 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
524 PermissionRecordManager::GetInstance().StartUsingPermission(
525 MakeInfo(tokenId, PID, "ohos.permission.READ_MEDIA"), CALLER_PID));
526
527 ASSERT_EQ(Constant::SUCCESS,
528 PermissionRecordManager::GetInstance().StopUsingPermission(
529 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
530 }
531
532 /*
533 * @tc.name: StartUsingPermissionTest008
534 * @tc.desc: Test multiple process start using permission
535 * @tc.type: FUNC
536 * @tc.require:
537 */
538 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest008, TestSize.Level1)
539 {
540 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
541
542 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
543 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
544 ASSERT_NE(nullptr, callback);
545 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
546 GetSelfTokenID(), permList, callback->AsObject()));
547
548 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
549 g_InfoParms1.instIndex);
550 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
551 std::string permissionName = "ohos.permission.CAMERA";
552 ASSERT_EQ(RET_SUCCESS,
553 PermissionRecordManager::GetInstance().StartUsingPermission(
554 MakeInfo(tokenId, TEST_PID_1, permissionName), CALLER_PID));
555 ASSERT_EQ(RET_SUCCESS,
556 PermissionRecordManager::GetInstance().StartUsingPermission(
557 MakeInfo(tokenId, TEST_PID_3, permissionName), CALLER_PID));
558 ProcessData processData;
559 processData.accessTokenId = tokenId;
560 processData.pid = TEST_PID_1;
561 appStateObserver_->OnProcessDied(processData);
562 usleep(500000); // 500000us = 0.5s
563 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
564
565 processData.pid = TEST_PID_2;
566 appStateObserver_->OnProcessDied(processData);
567 usleep(500000); // 500000us = 0.5s
568 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
569
570 processData.pid = TEST_PID_3;
571 appStateObserver_->OnProcessDied(processData);
572 usleep(500000); // 500000us = 0.5s
573 ASSERT_EQ(PERM_INACTIVE, callback->type_);
574 }
575
576 /*
577 * @tc.name: StartUsingPermissionTest009
578 * @tc.desc: Test multiple process start using permission
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest009, TestSize.Level1)
583 {
584 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
585
586 auto callbackPtr1 = std::make_shared<PermissionRecordManagerTestCb1>();
587 auto callbackWrap1 = new (std::nothrow) StateChangeCallback(callbackPtr1);
588 ASSERT_NE(nullptr, callbackPtr1);
589 ASSERT_NE(nullptr, callbackWrap1);
590
591 auto callbackPtr2 = std::make_shared<PermissionRecordManagerTestCb1>();
592 auto callbackWrap2 = new (std::nothrow) StateChangeCallback(callbackPtr2);
593 ASSERT_NE(nullptr, callbackPtr2);
594 ASSERT_NE(nullptr, callbackWrap2);
595
596 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
597 g_InfoParms1.instIndex);
598 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
599 std::string permissionName = "ohos.permission.CAMERA";
600
601 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
602 MakeInfo(tokenId, TEST_PID_1, permissionName), callbackWrap1->AsObject(), CALLER_PID));
603 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
604 MakeInfo(tokenId, TEST_PID_2, permissionName), callbackWrap2->AsObject(), CALLER_PID));
605
606 AppStateData appStateData;
607 appStateData.accessTokenId = tokenId;
608 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
609 appStateData.pid = TEST_PID_1;
610 appStateObserver_->OnAppStateChanged(appStateData);
611 appStateData.pid = TEST_PID_2;
612 appStateObserver_->OnAppStateChanged(appStateData);
613
614 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
615 appStateData.pid = TEST_PID_1;
616 appStateObserver_->OnAppStateChanged(appStateData);
617 usleep(500000); // 500000us = 0.5s
618 ASSERT_FALSE(callbackPtr1->isShow_);
619 ASSERT_TRUE(callbackPtr2->isShow_);
620
621 appStateData.pid = TEST_PID_2;
622 appStateObserver_->OnAppStateChanged(appStateData);
623 usleep(500000); // 500000us = 0.5s
624 ASSERT_FALSE(callbackPtr2->isShow_);
625 }
626
627 /*
628 * @tc.name: StartUsingPermissionTest010
629 * @tc.desc: Test multiple process start using permission
630 * @tc.type: FUNC
631 * @tc.require:
632 */
633 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest010, TestSize.Level1)
634 {
635 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
636
637 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
638 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
639 ASSERT_NE(nullptr, callback);
640 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
641 GetSelfTokenID(), permList, callback->AsObject()));
642
643 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
644 g_InfoParms1.instIndex);
645 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
646 std::string permissionName = "ohos.permission.CAMERA";
647 ASSERT_EQ(RET_SUCCESS,
648 PermissionRecordManager::GetInstance().StartUsingPermission(
649 MakeInfo(tokenId, TEST_PID_1, permissionName), CALLER_PID));
650 ASSERT_EQ(RET_SUCCESS,
651 PermissionRecordManager::GetInstance().StartUsingPermission(
652 MakeInfo(tokenId, TEST_PID_2, permissionName), CALLER_PID));
653
654 ASSERT_EQ(Constant::SUCCESS,
655 PermissionRecordManager::GetInstance().StopUsingPermission(
656 tokenId, TEST_PID_2, "ohos.permission.CAMERA", CALLER_PID));
657 usleep(500000); // 500000us = 0.5s
658 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callback->type_);
659
660 ASSERT_EQ(Constant::SUCCESS,
661 PermissionRecordManager::GetInstance().StopUsingPermission(
662 tokenId, TEST_PID_1, "ohos.permission.CAMERA", CALLER_PID));
663 usleep(500000); // 500000us = 0.5s
664 ASSERT_EQ(PERM_INACTIVE, callback->type_);
665 }
666
667 /*
668 * @tc.name: StartUsingPermissionTest011
669 * @tc.desc: Test default pid -1 start using permission and OnProcessDied
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest011, TestSize.Level1)
674 {
675 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
676
677 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
678 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
679 ASSERT_NE(nullptr, callback);
680 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
681 GetSelfTokenID(), permList, callback->AsObject()));
682 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
683 g_InfoParms1.instIndex);
684 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
685 std::string permissionName = "ohos.permission.CAMERA";
686 ASSERT_EQ(RET_SUCCESS,
687 PermissionRecordManager::GetInstance().StartUsingPermission(
688 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
689 ASSERT_EQ(PrivacyError::ERR_PERMISSION_ALREADY_START_USING,
690 PermissionRecordManager::GetInstance().StartUsingPermission(
691 MakeInfo(tokenId, PID, permissionName), CALLER_PID));
692
693 // makesure callback end
694 usleep(500000); // 500000us = 0.5s
695 callback->type_ = PERM_TEMPORARY_CALL;
696 ProcessData processData;
697 processData.accessTokenId = tokenId;
698 processData.pid = 100; // random pid
699 appStateObserver_->OnProcessDied(processData);
700 usleep(500000);
701 ASSERT_EQ(PERM_TEMPORARY_CALL, callback->type_);
702 }
703
704 #ifndef APP_SECURITY_PRIVACY_SERVICE
705 /*
706 * @tc.name: ShowGlobalDialog001
707 * @tc.desc: ShowGlobalDialog function test
708 * @tc.type: FUNC
709 * @tc.require: issueI5RWXF
710 */
711 HWTEST_F(PermissionRecordManagerTest, ShowGlobalDialog001, TestSize.Level1)
712 {
713 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
714
715 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.CAMERA"));
716 sleep(3); // wait for dialog disappear
717 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.MICROPHONE"));
718 sleep(3); // wait for dialog disappear
719 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog("ohos.permission.LOCATION")); // no dialog
720 }
721 #endif
722
723 /*
724 * @tc.name: AppStateChangeListener001
725 * @tc.desc: AppStateChange function test mic global switch is close
726 * @tc.type: FUNC
727 * @tc.require: issueI5RWXF
728 */
729 HWTEST_F(PermissionRecordManagerTest, AppStateChangeListener001, TestSize.Level1)
730 {
731 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
732
733 char value[VALUE_MAX_LEN] = {0};
734 GetParameter(EDM_MIC_MUTE_KEY, "", value, VALUE_MAX_LEN - 1);
735 GTEST_LOG_(INFO) << "value:" << value;
736
737 bool isMute = strncmp(value, "true", VALUE_MAX_LEN) == 0;
738 SetParameter(EDM_MIC_MUTE_KEY, std::to_string(false).c_str());
739
740 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
741 RANDOM_TOKENID);
742 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
743 g_InfoParms1.instIndex);
744 // status is inactive
745 ASSERT_EQ(RET_SUCCESS,
746 PermissionRecordManager::GetInstance().StartUsingPermission(
747 MakeInfo(tokenId, PID, "ohos.permission.MICROPHONE"), CALLER_PID));
748 sleep(3); // wait for dialog disappear
749 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, PERM_ACTIVE_IN_BACKGROUND);
750 ASSERT_EQ(RET_SUCCESS,
751 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID,
752 "ohos.permission.MICROPHONE", CALLER_PID));
753 std::string str = isMute ? "true" : "false";
754 SetParameter(EDM_MIC_MUTE_KEY, str.c_str());
755 }
756
757 /*
758 * @tc.name: TransferOpcodeToPermission001
759 * @tc.desc: Constant::TransferOpcodeToPermission function test return false
760 * @tc.type: FUNC
761 * @tc.require:
762 */
763 HWTEST_F(PermissionRecordManagerTest, TransferOpcodeToPermission001, TestSize.Level1)
764 {
765 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
766 std::string permissionName;
767 ASSERT_EQ(false, Constant::TransferOpcodeToPermission(opCode, permissionName));
768 }
769
770 /*
771 * @tc.name: AddPermissionUsedRecord001
772 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
773 * @tc.type: FUNC
774 * @tc.require:
775 */
776 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord001, TestSize.Level1)
777 {
778 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
779 g_InfoParms1.instIndex);
780 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
781
782 AddPermParamInfo info;
783 info.tokenId = tokenId;
784 info.permissionName = "com.ohos.test";
785 info.successCount = 1;
786 info.failCount = 0;
787
788 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
789 info)); // invaild permission error
790
791 info.type = PermissionUsedType::PICKER_TYPE;
792 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
793 info)); // invaild permission error
794
795 info.type = PermissionUsedType::SECURITY_COMPONENT_TYPE;
796 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(
797 info)); // invaild permission error
798 }
799
800 /*
801 * @tc.name: AddPermissionUsedRecord002
802 * @tc.desc: PermissionRecordManager::AddPermissionUsedRecord function test
803 * @tc.type: FUNC
804 * @tc.require:
805 */
806 HWTEST_F(PermissionRecordManagerTest, AddPermissionUsedRecord002, TestSize.Level1)
807 {
808 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
809 g_InfoParms1.instIndex);
810 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
811
812 AddPermParamInfo info;
813 info.tokenId = tokenId;
814 info.permissionName = "com.permission.READ_MEDIA";
815 info.successCount = 0;
816 info.failCount = 0;
817 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().AddPermissionUsedRecord(info));
818 }
819
820 /*
821 * @tc.name: RemovePermissionUsedRecords001
822 * @tc.desc: PermissionRecordManager::RemovePermissionUsedRecords function test
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(PermissionRecordManagerTest, RemovePermissionUsedRecords001, TestSize.Level1)
827 {
828 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
829 g_InfoParms1.instIndex);
830 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
831 }
832
833 /*
834 * @tc.name:SetPermissionUsedRecordToggleStatus001
835 * @tc.desc: PermissionRecordManager::SetPermissionUsedRecordToggleStatus function test
836 * @tc.type: FUNC
837 * @tc.require:
838 */
839 HWTEST_F(PermissionRecordManagerTest, SetPermissionUsedRecordToggleStatus001, TestSize.Level1)
840 {
841 int32_t ret = PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(
842 TEST_INVALID_USER_ID, true);
843 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
844
845 ret = PermissionRecordManager::GetInstance().SetPermissionUsedRecordToggleStatus(
846 TEST_INVALID_USER_ID_20000, true);
847 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
848 }
849
850 /*
851 * @tc.name:GetPermissionUsedRecordToggleStatus001
852 * @tc.desc: PermissionRecordManager::GetPermissionUsedRecordToggleStatus function test
853 * @tc.type: FUNC
854 * @tc.require:
855 */
856 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedRecordToggleStatus001, TestSize.Level1)
857 {
858 bool status = true;
859 int32_t ret = PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(
860 TEST_INVALID_USER_ID, status);
861 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
862
863 ret = PermissionRecordManager::GetInstance().GetPermissionUsedRecordToggleStatus(
864 TEST_INVALID_USER_ID_20000, status);
865 EXPECT_EQ(ret, PrivacyError::ERR_PARAM_INVALID);
866 }
867
868 /*
869 * @tc.name:UpdatePermUsedRecToggleStatusMap001
870 * @tc.desc: PermissionRecordManager::test UpdatePermUsedRecToggleStatusMap and CheckPermissionUsedRecordToggleStatus
871 * @tc.type: FUNC
872 * @tc.require:
873 */
874 HWTEST_F(PermissionRecordManagerTest, UpdatePermUsedRecToggleStatusMap001, TestSize.Level1)
875 {
876 bool checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
877 EXPECT_TRUE(checkStatus);
878
879 bool ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, false);
880 checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
881 EXPECT_TRUE(ret);
882 EXPECT_FALSE(checkStatus);
883
884 ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, false);
885 EXPECT_FALSE(ret);
886
887 ret = PermissionRecordManager::GetInstance().UpdatePermUsedRecToggleStatusMap(TEST_USER_ID_10, true);
888 checkStatus = PermissionRecordManager::GetInstance().CheckPermissionUsedRecordToggleStatus(TEST_USER_ID_10);
889 EXPECT_TRUE(ret);
890 EXPECT_TRUE(checkStatus);
891 }
892
893 /*
894 * @tc.name: StopUsingPermission001
895 * @tc.desc: PermissionRecordManager::StopUsingPermission function test
896 * @tc.type: FUNC
897 * @tc.require:
898 */
899 HWTEST_F(PermissionRecordManagerTest, StopUsingPermission001, TestSize.Level1)
900 {
901 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
902 g_InfoParms1.instIndex);
903 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
904
905 // tokenId invaild
906 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StopUsingPermission(
907 static_cast<AccessTokenID>(0), PID, "ohos.permission.READ_MEDIA", CALLER_PID));
908
909 // permission invaild
910 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST, PermissionRecordManager::GetInstance().StopUsingPermission(
911 tokenId, PID, "ohos.permission.test", CALLER_PID));
912
913 // not start using
914 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_START_USING,
915 PermissionRecordManager::GetInstance().StopUsingPermission(
916 tokenId, PID, "ohos.permission.READ_MEDIA", CALLER_PID));
917 }
918
919 /*
920 * @tc.name: RegisterPermActiveStatusCallback003
921 * @tc.desc: PermissionRecordManager::RegisterPermActiveStatusCallback function test
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback003, TestSize.Level1)
926 {
927 std::vector<std::string> permList;
928
929 permList.emplace_back("com.ohos.TEST");
930 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
931 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(
932 GetSelfTokenID(), permList, nullptr));
933 }
934
935 /*
936 * @tc.name: GetPermissionUsedType001
937 * @tc.desc: PermissionRecordManager::GetPermissionUsedType function test
938 * @tc.type: FUNC
939 * @tc.require:
940 */
941 HWTEST_F(PermissionRecordManagerTest, GetPermissionUsedType001, TestSize.Level1)
942 {
943 uint32_t tokenId = RANDOM_TOKENID;
944 std::string permissionName = "ohos.permission.PERMISSION_RECORD_MANAGER_TEST";
945 std::vector<PermissionUsedTypeInfo> results;
946 // tokenId is not exsit
947 ASSERT_EQ(PrivacyError::ERR_TOKENID_NOT_EXIST,
948 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
949
950 tokenId = 0;
951 // permissionName is not exsit
952 ASSERT_EQ(PrivacyError::ERR_PERMISSION_NOT_EXIST,
953 PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
954
955 permissionName = "ohos.permission.CAMERA";
956 ASSERT_EQ(0, PermissionRecordManager::GetInstance().GetPermissionUsedTypeInfos(tokenId, permissionName, results));
957 }
958
959 /**
960 * @tc.name: Dlopen001
961 * @tc.desc: Open a not exist lib & not exist func
962 * @tc.type: FUNC
963 * @tc.require:
964 */
965 HWTEST_F(PermissionRecordManagerTest, Dlopen001, TestSize.Level1)
966 {
967 LibraryLoader loader1("libnotexist.z.so"); // is a not exist path
968 EXPECT_EQ(nullptr, loader1.handle_);
969
970 LibraryLoader loader2("libaccesstoken_manager_service.z.so"); // is a exist lib without create func
971 EXPECT_EQ(nullptr, loader2.instance_);
972 EXPECT_NE(nullptr, loader2.handle_);
973 }
974
975 /*
976 * @tc.name: AddDataValueToResults001
977 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
978 * @tc.type: FUNC
979 * @tc.require:
980 */
981 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults001, TestSize.Level1)
982 {
983 GenericValues value;
984 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
985 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, NORMAL_TYPE_ADD_VALUE);
986 std::vector<PermissionUsedTypeInfo> results;
987
988 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
989 ASSERT_EQ(PermissionUsedType::NORMAL_TYPE, results[FIRST_INDEX].type);
990 }
991
992 /*
993 * @tc.name: AddDataValueToResults002
994 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults002, TestSize.Level1)
999 {
1000 GenericValues value;
1001 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
1002 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, PICKER_TYPE_ADD_VALUE);
1003 std::vector<PermissionUsedTypeInfo> results;
1004
1005 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
1006 ASSERT_EQ(PermissionUsedType::PICKER_TYPE, results[FIRST_INDEX].type);
1007 }
1008
1009 /*
1010 * @tc.name: AddDataValueToResults003
1011 * @tc.desc: PermissionRecordManager::AddDataValueToResults function test
1012 * @tc.type: FUNC
1013 * @tc.require:
1014 */
1015 HWTEST_F(PermissionRecordManagerTest, AddDataValueToResults003, TestSize.Level1)
1016 {
1017 GenericValues value;
1018 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(RANDOM_TOKENID));
1019 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, SEC_COMPONENT_TYPE_ADD_VALUE);
1020 std::vector<PermissionUsedTypeInfo> results;
1021
1022 PermissionRecordManager::GetInstance().AddDataValueToResults(value, results);
1023 ASSERT_EQ(PermissionUsedType::SECURITY_COMPONENT_TYPE, results[FIRST_INDEX].type);
1024 ASSERT_EQ(0, GetFirstCallerTokenID());
1025 }
1026
1027 /*
1028 * @tc.name: SetMutePolicyTest001
1029 * @tc.desc:
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest001, TestSize.Level1)
1034 {
1035 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1036 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1037 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1038 RANDOM_TOKENID);
1039 EXPECT_EQ(RET_SUCCESS,
1040 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1041
1042 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1043 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1044 RANDOM_TOKENID);
1045 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
1046 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1047 }
1048
1049 /*
1050 * @tc.name: SetMutePolicyTest002
1051 * @tc.desc:
1052 * @tc.type: FUNC
1053 * @tc.require:
1054 */
1055 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest002, TestSize.Level1)
1056 {
1057 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1058 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1059 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1060 RANDOM_TOKENID);
1061 EXPECT_EQ(RET_SUCCESS,
1062 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1063
1064 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1065 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1066 RANDOM_TOKENID);
1067 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED,
1068 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1069 }
1070
1071 /*
1072 * @tc.name: SetMutePolicyTest003
1073 * @tc.desc:
1074 * @tc.type: FUNC
1075 * @tc.require:
1076 */
1077 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest003, TestSize.Level1)
1078 {
1079 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1080 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1081 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1082 RANDOM_TOKENID);
1083 EXPECT_EQ(RET_SUCCESS,
1084 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID));
1085
1086 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1087 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1088 RANDOM_TOKENID);
1089 EXPECT_EQ(RET_SUCCESS,
1090 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID));
1091 }
1092
1093 /*
1094 * @tc.name: SetMutePolicyTest004
1095 * @tc.desc:
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 */
1099 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest004, TestSize.Level1)
1100 {
1101 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1102 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1103 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1104 RANDOM_TOKENID);
1105 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1106 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1107
1108 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1109 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1110 RANDOM_TOKENID);
1111 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED,
1112 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1113 RANDOM_TOKENID));
1114 }
1115
1116 /*
1117 * @tc.name: SetMutePolicyTest005
1118 * @tc.desc:
1119 * @tc.type: FUNC
1120 * @tc.require:
1121 */
1122 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest005, TestSize.Level1)
1123 {
1124 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1125 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1126 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1127 RANDOM_TOKENID);
1128 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1129 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1130
1131 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1132 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1133 RANDOM_TOKENID);
1134 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1135 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1136 }
1137
1138 /*
1139 * @tc.name: SetMutePolicyTest006
1140 * @tc.desc:
1141 * @tc.type: FUNC
1142 * @tc.require:
1143 */
1144 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest006, TestSize.Level1)
1145 {
1146 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1147 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1148 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1149 RANDOM_TOKENID);
1150 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1151 PolicyType::PRIVACY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1152
1153 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1154 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1155 RANDOM_TOKENID);
1156 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1157 PolicyType::PRIVACY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1158 }
1159
1160 /*
1161 * @tc.name: SetMutePolicyTest007
1162 * @tc.desc:
1163 * @tc.type: FUNC
1164 * @tc.require:
1165 */
1166 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest007, TestSize.Level1)
1167 {
1168 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1169 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1170 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1171 RANDOM_TOKENID);
1172 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1173 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1174
1175 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, true, tokenID);
1176 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1177 RANDOM_TOKENID);
1178 EXPECT_EQ(ERR_EDM_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
1179 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1180 }
1181
1182 #ifndef APP_SECURITY_PRIVACY_SERVICE
1183 /*
1184 * @tc.name: SetMutePolicyTest008
1185 * @tc.desc:
1186 * @tc.type: FUNC
1187 * @tc.require:
1188 */
1189 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest008, TestSize.Level1)
1190 {
1191 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
1192 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1193 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1194 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1195 RANDOM_TOKENID);
1196 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1197 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1198
1199 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1200 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, true,
1201 RANDOM_TOKENID);
1202 EXPECT_EQ(ERR_PRIVACY_POLICY_CHECK_FAILED, PermissionRecordManager::GetInstance().SetMutePolicy(
1203 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1204 }
1205 #endif
1206
1207 /*
1208 * @tc.name: SetMutePolicyTest009
1209 * @tc.desc:
1210 * @tc.type: FUNC
1211 * @tc.require:
1212 */
1213 HWTEST_F(PermissionRecordManagerTest, SetMutePolicyTest009, TestSize.Level1)
1214 {
1215 uint32_t tokenID = AccessTokenKit::GetNativeTokenId("edm");
1216 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1217 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1218 RANDOM_TOKENID);
1219 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1220 PolicyType::TEMPORARY, CallerType::MICROPHONE, true, RANDOM_TOKENID));
1221
1222 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::EDM, CallerType::MICROPHONE, false, tokenID);
1223 PermissionRecordManager::GetInstance().SetMutePolicy(PolicyType::PRIVACY, CallerType::MICROPHONE, false,
1224 RANDOM_TOKENID);
1225 EXPECT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().SetMutePolicy(
1226 PolicyType::TEMPORARY, CallerType::MICROPHONE, false, RANDOM_TOKENID));
1227 }
1228
1229 class DiedProxyMaker {
1230 public:
DiedProxyMaker()1231 DiedProxyMaker()
1232 {
1233 handler_ = std::make_shared<ProxyDeathHandler>();
1234 }
1235
AddRecipient(int callerPid)1236 void AddRecipient(int callerPid)
1237 {
1238 std::shared_ptr<ProxyDeathParam> param = std::make_shared<PrivacyManagerProxyDeathParam>(callerPid);
1239 auto anonyStub = sptr<ProxyDeathCallBackStub>::MakeSptr();
1240 handler_->AddProxyStub(anonyStub, param);
1241 }
1242
TestDie(int32_t callerPid)1243 void TestDie(int32_t callerPid)
1244 {
1245 auto map = handler_->proxyStubAndRecipientMap_;
1246 auto param = reinterpret_cast<ProxyDeathParam*>(new PrivacyManagerProxyDeathParam(callerPid));
1247 for (auto iter = map.begin(); iter != map.end(); ++iter) {
1248 if (iter->second.second->IsEqual(param)) {
1249 iter->second.first->OnRemoteDied(iter->first);
1250 }
1251 }
1252 }
1253
1254 std::shared_ptr<ProxyDeathHandler> handler_ = nullptr;
1255 };
1256
1257 /*
1258 * @tc.name: PermissionRecordManagerTest
1259 * @tc.desc: ProxyDeathTest test
1260 * @tc.type: FUNC
1261 * @tc.require:
1262 */
1263 HWTEST_F(PermissionRecordManagerTest, ProxyDeathTest001, TestSize.Level1)
1264 {
1265 DiedProxyMaker init;
1266 init.AddRecipient(CALLER_PID);
1267 init.TestDie(CALLER_PID);
1268 ASSERT_EQ(0, PermissionRecordManager::GetInstance().startRecordList_.size());
1269
1270 AccessTokenID tokenId1 = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
1271 g_InfoParms1.instIndex);
1272 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
1273 std::string permissionName = "ohos.permission.CAMERA";
1274 ASSERT_EQ(RET_SUCCESS,
1275 PermissionRecordManager::GetInstance().StartUsingPermission(
1276 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1277
1278 AccessTokenID tokenId2 = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
1279 g_InfoParms2.instIndex);
1280 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId2);
1281 ASSERT_EQ(RET_SUCCESS,
1282 PermissionRecordManager::GetInstance().StartUsingPermission(
1283 MakeInfo(tokenId2, TEST_PID_2, permissionName), CALLER_PID));
1284 ASSERT_EQ(2, PermissionRecordManager::GetInstance().startRecordList_.size());
1285
1286 DiedProxyMaker maker;
1287 maker.AddRecipient(CALLER_PID);
1288 maker.TestDie(CALLER_PID);
1289 ASSERT_EQ(0, PermissionRecordManager::GetInstance().startRecordList_.size());
1290 }
1291
1292 /*
1293 * @tc.name: PermissionRecordManagerTest
1294 * @tc.desc: ProxyDeathTest test
1295 * @tc.type: FUNC
1296 * @tc.require:
1297 */
1298 HWTEST_F(PermissionRecordManagerTest, ProxyDeathTest002, TestSize.Level1)
1299 {
1300 DiedProxyMaker init;
1301 init.AddRecipient(CALLER_PID);
1302 init.TestDie(CALLER_PID);
1303 AccessTokenID tokenId1 = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
1304 g_InfoParms1.instIndex);
1305 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
1306 std::string permissionName = "ohos.permission.CAMERA";
1307 ASSERT_EQ(RET_SUCCESS,
1308 PermissionRecordManager::GetInstance().StartUsingPermission(
1309 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1310
1311 AccessTokenID tokenId2 = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
1312 g_InfoParms2.instIndex);
1313 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId2);
1314 ASSERT_EQ(RET_SUCCESS,
1315 PermissionRecordManager::GetInstance().StartUsingPermission(
1316 MakeInfo(tokenId2, TEST_PID_2, permissionName), CALLER_PID2));
1317 ASSERT_EQ(2, PermissionRecordManager::GetInstance().startRecordList_.size());
1318
1319 DiedProxyMaker maker;
1320 maker.AddRecipient(CALLER_PID);
1321 maker.TestDie(CALLER_PID);
1322 ASSERT_EQ(1, PermissionRecordManager::GetInstance().startRecordList_.size());
1323
1324 ASSERT_EQ(RET_SUCCESS,
1325 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId2, TEST_PID_2, permissionName, CALLER_PID2));
1326 }
1327
1328 /*
1329 * @tc.name: PermissionRecordManagerTest
1330 * @tc.desc: HasCallerInStartList test
1331 * @tc.type: FUNC
1332 * @tc.require:
1333 */
1334 HWTEST_F(PermissionRecordManagerTest, HasCallerInStartList001, TestSize.Level1)
1335 {
1336 DiedProxyMaker init;
1337 init.AddRecipient(CALLER_PID);
1338 init.TestDie(CALLER_PID);
1339 AccessTokenID tokenId1 = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
1340 g_InfoParms1.instIndex);
1341 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
1342 std::string permissionName = "ohos.permission.CAMERA";
1343 ASSERT_EQ(RET_SUCCESS,
1344 PermissionRecordManager::GetInstance().StartUsingPermission(
1345 MakeInfo(tokenId1, TEST_PID_1, permissionName), CALLER_PID));
1346 ASSERT_TRUE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID));
1347 ASSERT_FALSE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID2));
1348 ASSERT_EQ(RET_SUCCESS,
1349 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId1, TEST_PID_1, permissionName, CALLER_PID));
1350 ASSERT_FALSE(PermissionRecordManager::GetInstance().HasCallerInStartList(CALLER_PID));
1351 }
1352 } // namespace AccessToken
1353 } // namespace Security
1354 } // namespace OHOS
1355