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 "accesstoken_kit.h"
19 #include "constant.h"
20 #include "privacy_field_const.h"
21 #define private public
22 #include "permission_record_manager.h"
23 #undef private
24 #include "perm_active_status_change_callback_stub.h"
25 #include "privacy_error.h"
26 #include "privacy_manager_service.h"
27 #include "string_ex.h"
28 #include "token_setproc.h"
29
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Security {
34 namespace AccessToken {
35 namespace {
36 static constexpr int32_t PERMISSION_USAGE_RECORDS_MAX_NUM = 10;
37 constexpr const char* CAMERA_PERMISSION_NAME = "ohos.permission.CAMERA";
38 constexpr const char* MICROPHONE_PERMISSION_NAME = "ohos.permission.MICROPHONE";
39 constexpr const char* LOCATION_PERMISSION_NAME = "ohos.permission.LOCATION";
40 static PermissionStateFull g_testState = {
41 .permissionName = "ohos.permission.CAMERA",
42 .isGeneral = true,
43 .resDeviceID = {"local"},
44 .grantStatus = {PermissionState::PERMISSION_GRANTED},
45 .grantFlags = {1}
46 };
47
48 static HapPolicyParams g_PolicyPrams1 = {
49 .apl = APL_NORMAL,
50 .domain = "test.domain.A",
51 .permList = {},
52 .permStateList = {g_testState}
53 };
54
55 static HapInfoParams g_InfoParms1 = {
56 .userID = 1,
57 .bundleName = "ohos.privacy_test.bundleA",
58 .instIndex = 0,
59 .appIDDesc = "privacy_test.bundleA"
60 };
61
62 static HapPolicyParams g_PolicyPrams2 = {
63 .apl = APL_NORMAL,
64 .domain = "test.domain.B",
65 .permList = {},
66 .permStateList = {g_testState}
67 };
68
69 static HapInfoParams g_InfoParms2 = {
70 .userID = 1,
71 .bundleName = "ohos.privacy_test.bundleB",
72 .instIndex = 0,
73 .appIDDesc = "privacy_test.bundleB"
74 };
75 }
76
77 class PrivacyManagerServiceTest : public testing::Test {
78 public:
79 static void SetUpTestCase();
80
81 static void TearDownTestCase();
82
83 void SetUp();
84
85 void TearDown();
86 std::shared_ptr<PrivacyManagerService> privacyManagerService_;
87 uint64_t selfTokenId_;
88 };
89
SetUpTestCase()90 void PrivacyManagerServiceTest::SetUpTestCase()
91 {
92 }
93
TearDownTestCase()94 void PrivacyManagerServiceTest::TearDownTestCase()
95 {
96 }
97
SetUp()98 void PrivacyManagerServiceTest::SetUp()
99 {
100 privacyManagerService_ = DelayedSingleton<PrivacyManagerService>::GetInstance();
101 PermissionRecordManager::GetInstance().Register();
102 EXPECT_NE(nullptr, privacyManagerService_);
103 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
104 AccessTokenKit::AllocHapToken(g_InfoParms2, g_PolicyPrams2);
105 selfTokenId_ = GetSelfTokenID();
106 }
107
TearDown()108 void PrivacyManagerServiceTest::TearDown()
109 {
110 privacyManagerService_ = nullptr;
111 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
112 g_InfoParms1.instIndex);
113 AccessTokenKit::DeleteToken(tokenId);
114 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
115 g_InfoParms2.instIndex);
116 AccessTokenKit::DeleteToken(tokenId);
117 SetSelfTokenID(selfTokenId_);
118 }
119
120 /**
121 * @tc.name: Dump001
122 * @tc.desc: Dump record info.
123 * @tc.type: FUNC
124 * @tc.require: issueI4V02P
125 */
126 HWTEST_F(PrivacyManagerServiceTest, Dump001, TestSize.Level1)
127 {
128 int32_t fd = -1;
129 std::vector<std::u16string> args;
130
131 // fd is 0
132 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
133
134 fd = 1; // 1: std output
135
136 // hidumper
137 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
138
139 // hidumper -h
140 args.emplace_back(Str8ToStr16("-h"));
141 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
142
143 args.clear();
144 // hidumper -t
145 args.emplace_back(Str8ToStr16("-t"));
146 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
147
148 args.clear();
149 // hidumper -t
150 args.emplace_back(Str8ToStr16("-t"));
151 args.emplace_back(Str8ToStr16("-1")); // illegal tokenId
152 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
153
154 args.clear();
155 // hidumper -t
156 args.emplace_back(Str8ToStr16("-s"));
157 ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
158
159 args.clear();
160 // hidumper -t
161 args.emplace_back(Str8ToStr16("-t"));
162 args.emplace_back(Str8ToStr16("123")); // 123: invalid tokenId
163 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
164 }
165
166 /**
167 * @tc.name: Dump002
168 * @tc.desc: Dump record info.
169 * @tc.type: FUNC
170 * @tc.require: issueI4V02P
171 */
172 HWTEST_F(PrivacyManagerServiceTest, Dump002, TestSize.Level1)
173 {
174 int32_t fd = 123; // 123: invalid fd
175 std::vector<std::u16string> args;
176 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
177 g_InfoParms1.instIndex);
178 args.emplace_back(Str8ToStr16("-t"));
179 std::string tokenIdStr = std::to_string(tokenId);
180 args.emplace_back(Str8ToStr16(tokenIdStr));
181
182 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
183
184 std::string permission = "ohos.permission.CAMERA";
185 for (int32_t i = 0; i < PERMISSION_USAGE_RECORDS_MAX_NUM; i++) {
186 privacyManagerService_->AddPermissionUsedRecord(tokenId, permission, 1, 0);
187 }
188
189 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
190
191 privacyManagerService_->AddPermissionUsedRecord(tokenId, permission, 1, 0);
192 ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
193 }
194
195 /*
196 * @tc.name: IsAllowedUsingPermission001
197 * @tc.desc: IsAllowedUsingPermission function test permissionName branch
198 * @tc.type: FUNC
199 * @tc.require: issueI5UPRK
200 */
201 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermission001, TestSize.Level1)
202 {
203 AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("privacy_service");
204 ASSERT_NE(INVALID_TOKENID, tokenId);
205 SetSelfTokenID(tokenId);
206 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
207 g_InfoParms1.instIndex);
208 ASSERT_NE(INVALID_TOKENID, tokenId);
209 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, false);
210 ASSERT_EQ(false, privacyManagerService_->IsAllowedUsingPermission(tokenId, CAMERA_PERMISSION_NAME));
211 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, true);
212 ASSERT_EQ(true, privacyManagerService_->IsAllowedUsingPermission(tokenId, CAMERA_PERMISSION_NAME));
213 ASSERT_EQ(false, privacyManagerService_->IsAllowedUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
214 ASSERT_EQ(false, privacyManagerService_->IsAllowedUsingPermission(tokenId, LOCATION_PERMISSION_NAME));
215 }
216
217 /*
218 * @tc.name: IsAllowedUsingPermission002
219 * @tc.desc: IsAllowedUsingPermission function test invalid tokenId
220 * @tc.type: FUNC
221 * @tc.require: issueI5UPRK
222 */
223 HWTEST_F(PrivacyManagerServiceTest, IsAllowedUsingPermission002, TestSize.Level1)
224 {
225 ASSERT_EQ(false, privacyManagerService_->IsAllowedUsingPermission(0, CAMERA_PERMISSION_NAME));
226 ASSERT_EQ(false, privacyManagerService_->IsAllowedUsingPermission(0, "test"));
227 }
228 } // namespace AccessToken
229 } // namespace Security
230 } // namespace OHOS
231