1 /*
2 * Copyright (c) 2023-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 "sec_comp_manager_test.h"
17
18 #include "sec_comp_log.h"
19 #define private public
20 #include "sec_comp_manager.h"
21 #undef private
22 #include "ipc_skeleton.h"
23 #include "iservice_registry.h"
24 #include "location_button.h"
25 #include "mock_system_ability_proxy.h"
26 #include "save_button.h"
27 #include "sec_comp_err.h"
28 #include "service_test_common.h"
29 #include "system_ability.h"
30
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::Security::SecurityComponent;
34 using namespace OHOS::Security::AccessToken;
35
36 namespace {
37 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
38 LOG_CORE, SECURITY_DOMAIN_SECURITY_COMPONENT, "SecCompManagerTest"};
39
BuildInvalidLocationComponent()40 static LocationButton BuildInvalidLocationComponent()
41 {
42 LocationButton button;
43 button.fontSize_ = ServiceTestCommon::TEST_INVALID_SIZE;
44 button.iconSize_ = ServiceTestCommon::TEST_INVALID_SIZE;
45 button.padding_.top = ServiceTestCommon::TEST_INVALID_SIZE;
46 button.padding_.right = ServiceTestCommon::TEST_INVALID_SIZE;
47 button.padding_.bottom = ServiceTestCommon::TEST_INVALID_SIZE;
48 button.padding_.left = ServiceTestCommon::TEST_INVALID_SIZE;
49 button.textIconSpace_ = ServiceTestCommon::TEST_INVALID_SIZE;
50 button.fontColor_.value = ServiceTestCommon::TEST_COLOR_WHITE;
51 button.iconColor_.value = ServiceTestCommon::TEST_COLOR_WHITE;
52 button.bgColor_.value = ServiceTestCommon::TEST_COLOR_WHITE;
53 button.borderWidth_ = ServiceTestCommon::TEST_INVALID_SIZE;
54 button.type_ = LOCATION_COMPONENT;
55 button.rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
56 button.rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
57 button.rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
58 button.rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
59 button.windowRect_.x_ = ServiceTestCommon::TEST_COORDINATE;
60 button.windowRect_.y_ = ServiceTestCommon::TEST_COORDINATE;
61 button.windowRect_.width_ = ServiceTestCommon::TEST_COORDINATE;
62 button.windowRect_.height_ = ServiceTestCommon::TEST_COORDINATE;
63 button.text_ = UNKNOWN_TEXT;
64 button.icon_ = UNKNOWN_ICON;
65 button.bg_ = SecCompBackground::UNKNOWN_BG;
66 return button;
67 }
68
BuildValidLocationComponent()69 static LocationButton BuildValidLocationComponent()
70 {
71 LocationButton button;
72 button.fontSize_ = ServiceTestCommon::TEST_SIZE;
73 button.iconSize_ = ServiceTestCommon::TEST_SIZE;
74 button.padding_.top = ServiceTestCommon::TEST_SIZE;
75 button.padding_.right = ServiceTestCommon::TEST_SIZE;
76 button.padding_.bottom = ServiceTestCommon::TEST_SIZE;
77 button.padding_.left = ServiceTestCommon::TEST_SIZE;
78 button.textIconSpace_ = ServiceTestCommon::TEST_SIZE;
79 button.fontColor_.value = ServiceTestCommon::TEST_COLOR_YELLOW;
80 button.iconColor_.value = ServiceTestCommon::TEST_COLOR_RED;
81 button.bgColor_.value = ServiceTestCommon::TEST_COLOR_BLUE;
82 button.borderWidth_ = ServiceTestCommon::TEST_SIZE;
83 button.type_ = LOCATION_COMPONENT;
84 button.rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
85 button.rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
86 button.rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
87 button.rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
88 button.windowRect_.x_ = ServiceTestCommon::TEST_COORDINATE;
89 button.windowRect_.y_ = ServiceTestCommon::TEST_COORDINATE;
90 button.windowRect_.width_ = ServiceTestCommon::TEST_COORDINATE;
91 button.windowRect_.height_ = ServiceTestCommon::TEST_COORDINATE;
92 button.text_ = static_cast<int32_t>(LocationDesc::SELECT_LOCATION);
93 button.icon_ = static_cast<int32_t>(LocationIcon::LINE_ICON);
94 button.bg_ = SecCompBackground::CIRCLE;
95 return button;
96 }
97 static const int32_t SLEEP_TIME = 5;
98 }
99
SetUpTestCase()100 void SecCompManagerTest::SetUpTestCase()
101 {}
102
TearDownTestCase()103 void SecCompManagerTest::TearDownTestCase()
104 {
105 if (SecCompManager::GetInstance().secRunner_ != nullptr) {
106 SecCompManager::GetInstance().secRunner_->queue_.reset();
107 SecCompManager::GetInstance().secRunner_ = nullptr;
108 }
109 if (SecCompManager::GetInstance().secHandler_ != nullptr) {
110 SecCompManager::GetInstance().secHandler_->eventRunner_.reset();
111 SecCompManager::GetInstance().secHandler_ = nullptr;
112 }
113 sleep(SLEEP_TIME);
114 }
115
SetUp()116 void SecCompManagerTest::SetUp()
117 {
118 SC_LOG_INFO(LABEL, "setup");
119 }
120
TearDown()121 void SecCompManagerTest::TearDown()
122 {
123 SecCompManager::GetInstance().componentMap_.clear();
124 }
125
126
127 /**
128 * @tc.name: CreateScId001
129 * @tc.desc: Test create sc id
130 * @tc.type: FUNC
131 * @tc.require: AR000HO9J7
132 */
133 HWTEST_F(SecCompManagerTest, CreateScId001, TestSize.Level1)
134 {
135 SecCompManager::GetInstance().scIdStart_ = ServiceTestCommon::MAX_INT_NUM;
136 ASSERT_EQ(ServiceTestCommon::SC_ID_START, SecCompManager::GetInstance().CreateScId());
137
138 SecCompManager::GetInstance().scIdStart_ = ServiceTestCommon::SC_ID_START;
139 ASSERT_EQ(ServiceTestCommon::SC_ID_START + 1, SecCompManager::GetInstance().CreateScId());
140 }
141
142 /**
143 * @tc.name: AddSecurityComponentToList001
144 * @tc.desc: Test add security component to list
145 * @tc.type: FUNC
146 * @tc.require: AR000HO9J7
147 */
148 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList001, TestSize.Level1)
149 {
150 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
151 ASSERT_NE(nullptr, compPtr);
152 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
153 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
154 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
155 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
156 std::shared_ptr<SecCompEntity> entity =
157 std::make_shared<SecCompEntity>(
158 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
159
160 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentToList(1, 0, entity));
161
162 std::shared_ptr<LocationButton> compPtrNew = std::make_shared<LocationButton>();
163 ASSERT_NE(nullptr, compPtrNew);
164 compPtrNew->rect_.x_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
165 compPtrNew->rect_.y_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
166 compPtrNew->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
167 compPtrNew->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
168 std::shared_ptr<SecCompEntity> entityNew =
169 std::make_shared<SecCompEntity>(
170 compPtrNew, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_2, 1, 1);
171 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentToList(1, 0, entityNew));
172 }
173
174 /**
175 * @tc.name: AddSecurityComponentToList002
176 * @tc.desc: Test add security component to list sa not exit
177 * @tc.type: FUNC
178 * @tc.require: AR000HO9J7
179 */
180 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList002, TestSize.Level1)
181 {
182 bool isSaExit = SecCompManager::GetInstance().isSaExit_;
183 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
184 ASSERT_NE(nullptr, compPtr);
185 std::shared_ptr<SecCompEntity> entity =
186 std::make_shared<SecCompEntity>(
187 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
188
189 ASSERT_NE(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
190 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
191 SecCompManager::GetInstance().isSaExit_ = isSaExit;
192 }
193
194 /**
195 * @tc.name: DeleteSecurityComponentFromList001
196 * @tc.desc: Test delete security component
197 * @tc.type: FUNC
198 * @tc.require: AR000HO9J7
199 */
200 HWTEST_F(SecCompManagerTest, DeleteSecurityComponentFromList001, TestSize.Level1)
201 {
202 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
203 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
204
205 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
206 ASSERT_NE(nullptr, compPtr);
207 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
208 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
209 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
210 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
211 std::shared_ptr<SecCompEntity> entity =
212 std::make_shared<SecCompEntity>(
213 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
214 ASSERT_EQ(SC_OK,
215 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
216
217 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
218 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_2));
219
220 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
221 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
222 }
223
224 /**
225 * @tc.name: GetSecurityComponentFromList001
226 * @tc.desc: Test get security component
227 * @tc.type: FUNC
228 * @tc.require: AR000HO9J7
229 */
230 HWTEST_F(SecCompManagerTest, GetSecurityComponentFromList001, TestSize.Level1)
231 {
232 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
233 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
234
235 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
236 ASSERT_NE(nullptr, compPtr);
237 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
238 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
239 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
240 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
241 std::shared_ptr<SecCompEntity> entity =
242 std::make_shared<SecCompEntity>(
243 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
244 ASSERT_EQ(SC_OK,
245 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
246 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
247 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_2));
248 ASSERT_NE(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
249 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
250 }
251
252 /**
253 * @tc.name: NotifyProcessBackground001
254 * @tc.desc: Test notify process background
255 * @tc.type: FUNC
256 * @tc.require: AR000HO9J7
257 */
258 HWTEST_F(SecCompManagerTest, NotifyProcessBackground001, TestSize.Level1)
259 {
260 SecCompManager::GetInstance().NotifyProcessBackground(ServiceTestCommon::TEST_PID_1);
261
262 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
263 ASSERT_NE(nullptr, compPtr);
264 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
265 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
266 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
267 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
268 std::shared_ptr<SecCompEntity> entity =
269 std::make_shared<SecCompEntity>(
270 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
271 ASSERT_EQ(SC_OK,
272 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
273 auto component = SecCompManager::GetInstance().GetSecurityComponentFromList(
274 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1);
275 ASSERT_NE(nullptr, component);
276 SecCompManager::GetInstance().NotifyProcessForeground(ServiceTestCommon::TEST_PID_1);
277 ASSERT_TRUE(SecCompManager::GetInstance().IsForegroundCompExist());
278 SecCompManager::GetInstance().NotifyProcessBackground(ServiceTestCommon::TEST_PID_1);
279 ASSERT_FALSE(SecCompManager::GetInstance().IsForegroundCompExist());
280 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_1, false);
281 ASSERT_FALSE(SecCompManager::GetInstance().IsForegroundCompExist());
282 }
283
284 /**
285 * @tc.name: NotifyProcessDied001
286 * @tc.desc: Test notify process died
287 * @tc.type: FUNC
288 * @tc.require: AR000HO9J7
289 */
290 HWTEST_F(SecCompManagerTest, NotifyProcessDied001, TestSize.Level1)
291 {
292 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
293 ASSERT_NE(nullptr, compPtr);
294 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
295 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
296 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
297 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
298 std::shared_ptr<SecCompEntity> entity =
299 std::make_shared<SecCompEntity>(
300 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
301 ASSERT_EQ(SC_OK,
302 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
303
304 std::shared_ptr<LocationButton> compPtr2 = std::make_shared<LocationButton>();
305 ASSERT_NE(nullptr, compPtr2);
306 compPtr2->rect_.x_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
307 compPtr2->rect_.y_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
308 compPtr2->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
309 compPtr2->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
310 std::shared_ptr<SecCompEntity> entity2 =
311 std::make_shared<SecCompEntity>(
312 compPtr2, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_2, 1, 1);
313 ASSERT_EQ(SC_OK,
314 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_2, 0, entity2));
315
316 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_3, false);
317 ASSERT_NE(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
318 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
319
320 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_1, false);
321 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
322 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
323 }
324
325 /**
326 * @tc.name: RegisterSecurityComponent001
327 * @tc.desc: Test register security component
328 * @tc.type: FUNC
329 * @tc.require: AR000HO9J7
330 */
331 HWTEST_F(SecCompManagerTest, RegisterSecurityComponent001, TestSize.Level1)
332 {
333 SecCompCallerInfo caller = {
334 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
335 .uid = 1,
336 .pid = ServiceTestCommon::TEST_PID_1
337 };
338 int32_t scId;
339 SecCompManager::GetInstance().malicious_.maliciousAppList_.insert(ServiceTestCommon::TEST_PID_1);
340 nlohmann::json jsonInvalid;
341 EXPECT_EQ(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST,
342 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonInvalid, caller, scId));
343 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
344
345 LocationButton buttonInvalid = BuildInvalidLocationComponent();
346 buttonInvalid.ToJson(jsonInvalid);
347 EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID,
348 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonInvalid, caller, scId));
349
350 nlohmann::json jsonValid;
351 LocationButton buttonValid = BuildValidLocationComponent();
352 buttonValid.ToJson(jsonValid);
353
354 EXPECT_EQ(SC_OK,
355 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonValid, caller, scId));
356 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
357 }
358
359 /**
360 * @tc.name: UpdateSecurityComponent001
361 * @tc.desc: Test update security component
362 * @tc.type: FUNC
363 * @tc.require: AR000HO9J7
364 */
365 HWTEST_F(SecCompManagerTest, UpdateSecurityComponent001, TestSize.Level1)
366 {
367 SecCompManager::GetInstance().malicious_.maliciousAppList_.insert(ServiceTestCommon::TEST_PID_1);
368 nlohmann::json jsonValid;
369 LocationButton buttonValid = BuildValidLocationComponent();
370 buttonValid.ToJson(jsonValid);
371 SecCompCallerInfo caller = {
372 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
373 .uid = 1,
374 .pid = ServiceTestCommon::TEST_PID_1
375 };
376 EXPECT_EQ(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST,
377 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
378 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
379
380 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
381 compPtr->type_ = LOCATION_COMPONENT;
382 std::shared_ptr<SecCompEntity> entity =
383 std::make_shared<SecCompEntity>(
384 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
385 EXPECT_EQ(SC_OK,
386 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
387
388 // wrong json
389 nlohmann::json jsonInvalid;
390 LocationButton buttonInvalid = BuildInvalidLocationComponent();
391 buttonInvalid.ToJson(jsonInvalid);
392 EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID,
393 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonInvalid, caller));
394
395 // no enhance data
396 EXPECT_EQ(SC_OK,
397 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
398 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
399 }
400
401 /**
402 * @tc.name: UnregisterSecurityComponent001
403 * @tc.desc: Test unregister security component
404 * @tc.type: FUNC
405 * @tc.require: AR000HO9J7
406 */
407 HWTEST_F(SecCompManagerTest, UnregisterSecurityComponent001, TestSize.Level1)
408 {
409 SecCompCallerInfo caller = {
410 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
411 .pid = ServiceTestCommon::TEST_PID_1
412 };
413
414 ASSERT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
415 SecCompManager::GetInstance().UnregisterSecurityComponent(ServiceTestCommon::TEST_INVALID_SC_ID, caller));
416 }
417
418 /**
419 * @tc.name: ReportSecurityComponentClickEvent001
420 * @tc.desc: Test report security component click
421 * @tc.type: FUNC
422 * @tc.require: AR000HO9J7
423 */
424 HWTEST_F(SecCompManagerTest, ReportSecurityComponentClickEvent001, TestSize.Level1)
425 {
426 SecCompCallerInfo caller = {
427 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
428 .pid = ServiceTestCommon::TEST_PID_1
429 };
430 SecCompClickEvent clickInfo;
431 nlohmann::json jsonVaild;
432 LocationButton buttonValid = BuildValidLocationComponent();
433 buttonValid.ToJson(jsonVaild);
434 std::vector<sptr<IRemoteObject>> remote = { nullptr, nullptr };
435 int32_t scId = 1;
436 SecCompInfo secCompInfo{ scId, "", clickInfo};
437 std::string message;
438 ASSERT_NE(SC_OK, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(secCompInfo,
439 jsonVaild, caller, remote, message));
440 }
441
442 /**
443 * @tc.name: AddSecurityComponentToList004
444 * @tc.desc: Test add security component too many components
445 * @tc.type: FUNC
446 * @tc.require:
447 */
448 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList004, TestSize.Level1)
449 {
450 std::shared_ptr<SecCompManager> managerInstance = std::make_shared<SecCompManager>();
451 managerInstance->isSaExit_ = false;
452 int pid = 1;
453 std::shared_ptr<SecCompEntity> entity =
454 std::make_shared<SecCompEntity>(
455 nullptr, 0, 0, 1, 1);
456 const int MAX_COMPONENT_SIZE = 500;
457 for (int i = 0; i < MAX_COMPONENT_SIZE; i++) {
458 managerInstance->componentMap_[pid].compList.emplace_back(entity);
459 }
460
461 ASSERT_NE(managerInstance->AddSecurityComponentToList(pid, 0, entity), SC_SERVICE_ERROR_VALUE_INVALID);
462 }
463
464 /**
465 * @tc.name: CheckClickSecurityComponentInfo001
466 * @tc.desc: Test check click security component info failed
467 * @tc.type: FUNC
468 * @tc.require: AR000HO9J7
469 */
470 HWTEST_F(SecCompManagerTest, CheckClickSecurityComponentInfo001, TestSize.Level1)
471 {
472 SecCompCallerInfo caller = {
473 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
474 .pid = ServiceTestCommon::TEST_PID_1
475 };
476 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
477 ASSERT_NE(nullptr, compPtr);
478
479 std::shared_ptr<SecCompEntity> entity =
480 std::make_shared<SecCompEntity>(
481 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
482 ASSERT_EQ(SC_OK,
483 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
484
485 SecCompClickEvent clickInfo;
486 nlohmann::json jsonVaild;
487 LocationButton buttonValid = BuildValidLocationComponent();
488 buttonValid.ToJson(jsonVaild);
489 jsonVaild[JsonTagConstants::JSON_SC_TYPE] = UNKNOWN_SC_TYPE;
490 std::vector<sptr<IRemoteObject>> remote = { nullptr, nullptr };
491 SecCompInfo secCompInfo{ ServiceTestCommon::TEST_SC_ID_1, "", clickInfo };
492 std::string message;
493 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
494 secCompInfo, jsonVaild, caller, remote, message));
495
496 jsonVaild[JsonTagConstants::JSON_SC_TYPE] = LOCATION_COMPONENT;
497 jsonVaild[JsonTagConstants::JSON_RECT][JsonTagConstants::JSON_RECT_X] = ServiceTestCommon::TEST_INVALID_DIMENSION;
498 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
499 secCompInfo, jsonVaild, caller, remote, message));
500
501 jsonVaild[JsonTagConstants::JSON_RECT][JsonTagConstants::JSON_RECT_X] = ServiceTestCommon::TEST_COORDINATE - 1;
502 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
503 secCompInfo, jsonVaild, caller, remote, message));
504 }
505
506 /**
507 * @tc.name: AddSecurityComponentToList003
508 * @tc.desc: Test add security component to list sa not exit
509 * @tc.type: FUNC
510 * @tc.require: AR000HO9J7
511 */
512 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList003, TestSize.Level1)
513 {
514 SecCompManager::GetInstance().isSaExit_ = true;
515 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
516 std::shared_ptr<SecCompEntity> entity =
517 std::make_shared<SecCompEntity>(
518 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
519 ASSERT_EQ(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
520 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
521 SecCompManager::GetInstance().isSaExit_ = false;
522 }
523
524 /**
525 * @tc.name: DeleteSecurityComponentFromList002
526 * @tc.desc: Test delete security component
527 * @tc.type: FUNC
528 * @tc.require: AR000HO9J7
529 */
530 HWTEST_F(SecCompManagerTest, DeleteSecurityComponentFromList002, TestSize.Level1)
531 {
532 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
533 ASSERT_NE(nullptr, compPtr);
534 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
535 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
536 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
537 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
538 std::shared_ptr<SecCompEntity> entity =
539 std::make_shared<SecCompEntity>(
540 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
541 ASSERT_EQ(SC_OK,
542 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
543
544 auto component = SecCompManager::GetInstance().GetSecurityComponentFromList(1, 1);
545 ASSERT_NE(nullptr, component);
546 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().DeleteSecurityComponentFromList(1, 1));
547 }
548
549 /**
550 * @tc.name: UpdateSecurityComponent002
551 * @tc.desc: Test update security component
552 * @tc.type: FUNC
553 * @tc.require: AR000HO9J7
554 */
555 HWTEST_F(SecCompManagerTest, UpdateSecurityComponent002, TestSize.Level1)
556 {
557 nlohmann::json jsonValid;
558 SecCompCallerInfo caller = {
559 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
560 .pid = ServiceTestCommon::TEST_PID_1
561 };
562 ASSERT_NE(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().UpdateSecurityComponent(
563 ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
564
565 SecCompManager::GetInstance().malicious_.AddAppToMaliciousAppList(ServiceTestCommon::TEST_PID_1);
566 LocationButton buttonValid = BuildValidLocationComponent();
567 buttonValid.ToJson(jsonValid);
568 ASSERT_NE(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST, SecCompManager::GetInstance().UpdateSecurityComponent(
569 ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
570 }
571
572 /**
573 * @tc.name: ExitSaProcess001
574 * @tc.desc: Test check ExitSaProcess
575 * @tc.type: FUNC
576 * @tc.require: AR000HO9J7
577 */
578 HWTEST_F(SecCompManagerTest, ExitSaProcess001, TestSize.Level1)
579 {
580 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
581 ASSERT_NE(nullptr, compPtr);
582 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
583 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
584 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
585 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
586 std::shared_ptr<SecCompEntity> entity =
587 std::make_shared<SecCompEntity>(
588 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
589 std::shared_ptr<SecCompManager> instance = std::make_shared<SecCompManager>();
590 ASSERT_EQ(SC_OK,
591 instance->AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
592 instance->ExitSaProcess();
593 EXPECT_FALSE(instance->isSaExit_);
594
595 instance->componentMap_.clear();
596 instance->ExitSaProcess();
597 EXPECT_TRUE(instance->isSaExit_);
598 instance->isSaExit_ = false;
599
600 std::shared_ptr<SystemAbilityManagerClient> saClient = std::make_shared<SystemAbilityManagerClient>();
601 ASSERT_NE(nullptr, saClient);
602 SystemAbilityManagerClient::clientInstance = saClient.get();
603 sptr<SystemAbilityManagerProxy> proxy = new SystemAbilityManagerProxy(nullptr);
604 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
605 instance->ExitSaProcess();
606 EXPECT_TRUE(instance->isSaExit_);
607 instance->isSaExit_ = false;
608
609 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
610 EXPECT_CALL(*proxy, UnloadSystemAbility(testing::_)).WillOnce(testing::Return(-1));
611 instance->ExitSaProcess();
612 EXPECT_TRUE(instance->isSaExit_);
613 }
614
615 /**
616 * @tc.name: ExitWhenAppMgrDied001
617 * @tc.desc: Test check ExitWhenAppMgrDied
618 * @tc.type: FUNC
619 * @tc.require: AR000HO9J7
620 */
621 HWTEST_F(SecCompManagerTest, ExitWhenAppMgrDied001, TestSize.Level1)
622 {
623 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
624 ASSERT_NE(nullptr, compPtr);
625 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
626 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
627 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
628 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
629 std::shared_ptr<SecCompEntity> entity =
630 std::make_shared<SecCompEntity>(
631 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
632
633 std::shared_ptr<SystemAbilityManagerClient> saClient = std::make_shared<SystemAbilityManagerClient>();
634 ASSERT_NE(nullptr, saClient);
635 SystemAbilityManagerClient::clientInstance = saClient.get();
636
637 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(nullptr));
638 std::shared_ptr<SecCompManager> instance = std::make_shared<SecCompManager>();
639 EXPECT_EQ(SC_OK, instance->AddSecurityComponentToList(1, 0, entity));
640 instance->ExitWhenAppMgrDied();
641 EXPECT_TRUE(instance->isSaExit_);
642
643 sptr<SystemAbilityManagerProxy> proxy = new SystemAbilityManagerProxy(nullptr);
644 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
645 instance->ExitWhenAppMgrDied();
646 EXPECT_TRUE(instance->isSaExit_);
647
648 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
649 instance->ExitWhenAppMgrDied();
650 EXPECT_TRUE(instance->isSaExit_);
651
652 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
653 EXPECT_CALL(*proxy, UnloadSystemAbility(testing::_)).WillOnce(testing::Return(-1));
654 instance->ExitWhenAppMgrDied();
655 EXPECT_TRUE(instance->isSaExit_);
656 }
657
658 /**
659 * @tc.name: SendCheckInfoEnhanceSysEvent001
660 * @tc.desc: Test check SendCheckInfoEnhanceSysEvent
661 * @tc.type: FUNC
662 * @tc.require: AR000HO9J7
663 */
664 HWTEST_F(SecCompManagerTest, SendCheckInfoEnhanceSysEvent001, TestSize.Level1)
665 {
666 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
667 ASSERT_TRUE(SecCompManager::GetInstance().malicious_.IsMaliciousAppListEmpty());
668 int32_t scId = INVALID_SC_ID;
669 const std::string scene = "";
670 int32_t res = SC_ENHANCE_ERROR_CHALLENGE_CHECK_FAIL;
671 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
672 }
673
674 /**
675 * @tc.name: DumpSecComp001
676 * @tc.desc: Test check DumpSecComp
677 * @tc.type: FUNC
678 * @tc.require: AR000HO9J7
679 */
680 HWTEST_F(SecCompManagerTest, DumpSecComp001, TestSize.Level1)
681 {
682 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
683 ASSERT_NE(nullptr, compPtr);
684 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
685 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
686 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
687 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
688 std::shared_ptr<SecCompEntity> entity =
689 std::make_shared<SecCompEntity>(
690 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
691 SecCompManager::GetInstance().isSaExit_ = false;
692 ASSERT_EQ(SC_OK,
693 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
694 std::string dumpStr;
695 SecCompManager::GetInstance().DumpSecComp(dumpStr);
696 }
697
698 /**
699 * @tc.name: TransformCallBackResult001
700 * @tc.desc: Test check TransformCallBackResult
701 * @tc.type: FUNC
702 * @tc.require: AR000HO9J7
703 */
704 HWTEST_F(SecCompManagerTest, TransformCallBackResult001, TestSize.Level1)
705 {
706 int32_t scId = INVALID_SC_ID;
707 const std::string scene = "REGISTER";
708 int32_t res = SC_ENHANCE_ERROR_NOT_EXIST_ENHANCE;
709 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
710 res = SC_ENHANCE_ERROR_VALUE_INVALID;
711 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
712 res = SC_ENHANCE_ERROR_CALLBACK_OPER_FAIL;
713 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
714 res = SC_SERVICE_ERROR_COMPONENT_INFO_INVALID;
715 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
716 res = SC_ENHANCE_ERROR_CALLBACK_CHECK_FAIL;
717 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
718 res = SC_SERVICE_ERROR_VALUE_INVALID;
719 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
720 }
721
722 /**
723 * @tc.name: AddSecurityComponentProcess001
724 * @tc.desc: Test AddSecurityComponentProcess
725 * @tc.type: FUNC
726 * @tc.require:
727 */
728 HWTEST_F(SecCompManagerTest, AddSecurityComponentProcess001, TestSize.Level1)
729 {
730 bool isSaExit = SecCompManager::GetInstance().isSaExit_;
731 SecCompManager::GetInstance().isSaExit_ = true;
732 SecCompCallerInfo info = {
733 .pid = 0,
734 .tokenId = 0,
735 .uid = 0,
736 };
737 EXPECT_EQ(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
738 SecCompManager::GetInstance().AddSecurityComponentProcess(info));
739 auto oldmap = SecCompManager::GetInstance().componentMap_;
740 SecCompManager::GetInstance().componentMap_.clear();
741 SecCompManager::GetInstance().isSaExit_ = false;
742 EXPECT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentProcess(info));
743 SecCompManager::GetInstance().componentMap_ = oldmap;
744 SecCompManager::GetInstance().isSaExit_ = isSaExit;
745 }