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:
132 */
133 HWTEST_F(SecCompManagerTest, CreateScId001, TestSize.Level0)
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: CreateScId002
144 * @tc.desc: Test create sc id
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(SecCompManagerTest, CreateScId002, TestSize.Level0)
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::SC_ID_START, 1, 1);
159 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentToList(1, 0, entity));
160
161 SecCompManager::GetInstance().scIdStart_ = ServiceTestCommon::MAX_INT_NUM;
162 ASSERT_EQ(ServiceTestCommon::SC_ID_START + 1, SecCompManager::GetInstance().CreateScId());
163 }
164
165 /**
166 * @tc.name: AddSecurityComponentToList001
167 * @tc.desc: Test add security component to list
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList001, TestSize.Level0)
172 {
173 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
174 ASSERT_NE(nullptr, compPtr);
175 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
176 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
177 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
178 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
179 std::shared_ptr<SecCompEntity> entity =
180 std::make_shared<SecCompEntity>(
181 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
182
183 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentToList(1, 0, entity));
184
185 std::shared_ptr<LocationButton> compPtrNew = std::make_shared<LocationButton>();
186 ASSERT_NE(nullptr, compPtrNew);
187 compPtrNew->rect_.x_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
188 compPtrNew->rect_.y_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
189 compPtrNew->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
190 compPtrNew->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
191 std::shared_ptr<SecCompEntity> entityNew =
192 std::make_shared<SecCompEntity>(
193 compPtrNew, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_2, 1, 1);
194 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentToList(1, 0, entityNew));
195 }
196
197 /**
198 * @tc.name: AddSecurityComponentToList002
199 * @tc.desc: Test add security component to list sa not exit
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList002, TestSize.Level0)
204 {
205 bool isSaExit = SecCompManager::GetInstance().isSaExit_;
206 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
207 ASSERT_NE(nullptr, compPtr);
208 std::shared_ptr<SecCompEntity> entity =
209 std::make_shared<SecCompEntity>(
210 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
211
212 ASSERT_NE(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
213 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
214 SecCompManager::GetInstance().isSaExit_ = isSaExit;
215 }
216
217 /**
218 * @tc.name: DeleteSecurityComponentFromList001
219 * @tc.desc: Test delete security component
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(SecCompManagerTest, DeleteSecurityComponentFromList001, TestSize.Level0)
224 {
225 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
226 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
227
228 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
229 ASSERT_NE(nullptr, compPtr);
230 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
231 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
232 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
233 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
234 std::shared_ptr<SecCompEntity> entity =
235 std::make_shared<SecCompEntity>(
236 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
237 ASSERT_EQ(SC_OK,
238 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
239
240 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
241 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_2));
242
243 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().DeleteSecurityComponentFromList(
244 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
245 }
246
247 /**
248 * @tc.name: GetSecurityComponentFromList001
249 * @tc.desc: Test get security component
250 * @tc.type: FUNC
251 * @tc.require:
252 */
253 HWTEST_F(SecCompManagerTest, GetSecurityComponentFromList001, TestSize.Level0)
254 {
255 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
256 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
257
258 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
259 ASSERT_NE(nullptr, compPtr);
260 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
261 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
262 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
263 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
264 std::shared_ptr<SecCompEntity> entity =
265 std::make_shared<SecCompEntity>(
266 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
267 ASSERT_EQ(SC_OK,
268 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
269 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
270 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_2));
271 ASSERT_NE(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
272 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
273 }
274
275 /**
276 * @tc.name: NotifyProcessBackground001
277 * @tc.desc: Test notify process background
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(SecCompManagerTest, NotifyProcessBackground001, TestSize.Level0)
282 {
283 SecCompManager::GetInstance().NotifyProcessBackground(ServiceTestCommon::TEST_PID_1);
284
285 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
286 ASSERT_NE(nullptr, compPtr);
287 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
288 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
289 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
290 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
291 std::shared_ptr<SecCompEntity> entity =
292 std::make_shared<SecCompEntity>(
293 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
294 ASSERT_EQ(SC_OK,
295 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
296 auto component = SecCompManager::GetInstance().GetSecurityComponentFromList(
297 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1);
298 ASSERT_NE(nullptr, component);
299 SecCompManager::GetInstance().NotifyProcessForeground(ServiceTestCommon::TEST_PID_1);
300 ASSERT_TRUE(SecCompManager::GetInstance().IsForegroundCompExist());
301 SecCompManager::GetInstance().NotifyProcessBackground(ServiceTestCommon::TEST_PID_1);
302 ASSERT_FALSE(SecCompManager::GetInstance().IsForegroundCompExist());
303 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_1, false);
304 ASSERT_FALSE(SecCompManager::GetInstance().IsForegroundCompExist());
305 }
306
307 /**
308 * @tc.name: NotifyProcessDied001
309 * @tc.desc: Test notify process died
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(SecCompManagerTest, NotifyProcessDied001, TestSize.Level0)
314 {
315 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
316 ASSERT_NE(nullptr, compPtr);
317 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
318 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
319 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
320 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
321 std::shared_ptr<SecCompEntity> entity =
322 std::make_shared<SecCompEntity>(
323 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
324 ASSERT_EQ(SC_OK,
325 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
326
327 std::shared_ptr<LocationButton> compPtr2 = std::make_shared<LocationButton>();
328 ASSERT_NE(nullptr, compPtr2);
329 compPtr2->rect_.x_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
330 compPtr2->rect_.y_ = ServiceTestCommon::TEST_COORDINATE * 2; // not overlap
331 compPtr2->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
332 compPtr2->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
333 std::shared_ptr<SecCompEntity> entity2 =
334 std::make_shared<SecCompEntity>(
335 compPtr2, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_2, 1, 1);
336 ASSERT_EQ(SC_OK,
337 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_2, 0, entity2));
338
339 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_3, false);
340 ASSERT_NE(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
341 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
342
343 SecCompManager::GetInstance().NotifyProcessDied(ServiceTestCommon::TEST_PID_1, false);
344 ASSERT_EQ(nullptr, SecCompManager::GetInstance().GetSecurityComponentFromList(
345 ServiceTestCommon::TEST_PID_1, ServiceTestCommon::TEST_SC_ID_1));
346 }
347
348 /**
349 * @tc.name: RegisterSecurityComponent001
350 * @tc.desc: Test register security component
351 * @tc.type: FUNC
352 * @tc.require:
353 */
354 HWTEST_F(SecCompManagerTest, RegisterSecurityComponent001, TestSize.Level0)
355 {
356 SecCompCallerInfo caller = {
357 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
358 .uid = 1,
359 .pid = ServiceTestCommon::TEST_PID_1
360 };
361 int32_t scId;
362 SecCompManager::GetInstance().malicious_.maliciousAppList_.insert(ServiceTestCommon::TEST_PID_1);
363 nlohmann::json jsonInvalid;
364 EXPECT_EQ(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST,
365 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonInvalid, caller, scId));
366 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
367
368 LocationButton buttonInvalid = BuildInvalidLocationComponent();
369 buttonInvalid.ToJson(jsonInvalid);
370 EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID,
371 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonInvalid, caller, scId));
372
373 nlohmann::json jsonValid;
374 LocationButton buttonValid = BuildValidLocationComponent();
375 buttonValid.ToJson(jsonValid);
376
377 EXPECT_EQ(SC_OK,
378 SecCompManager::GetInstance().RegisterSecurityComponent(LOCATION_COMPONENT, jsonValid, caller, scId));
379 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
380 }
381
382 /**
383 * @tc.name: UpdateSecurityComponent001
384 * @tc.desc: Test update security component
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(SecCompManagerTest, UpdateSecurityComponent001, TestSize.Level0)
389 {
390 SecCompManager::GetInstance().malicious_.maliciousAppList_.insert(ServiceTestCommon::TEST_PID_1);
391 nlohmann::json jsonValid;
392 LocationButton buttonValid = BuildValidLocationComponent();
393 buttonValid.ToJson(jsonValid);
394 SecCompCallerInfo caller = {
395 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
396 .uid = 1,
397 .pid = ServiceTestCommon::TEST_PID_1
398 };
399 EXPECT_EQ(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST,
400 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
401 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
402
403 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
404 compPtr->type_ = LOCATION_COMPONENT;
405 std::shared_ptr<SecCompEntity> entity =
406 std::make_shared<SecCompEntity>(
407 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
408 EXPECT_EQ(SC_OK,
409 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
410
411 // wrong json
412 nlohmann::json jsonInvalid;
413 LocationButton buttonInvalid = BuildInvalidLocationComponent();
414 buttonInvalid.ToJson(jsonInvalid);
415 EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID,
416 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonInvalid, caller));
417
418 // no enhance data
419 EXPECT_EQ(SC_OK,
420 SecCompManager::GetInstance().UpdateSecurityComponent(ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
421 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
422 }
423
424 /**
425 * @tc.name: UnregisterSecurityComponent001
426 * @tc.desc: Test unregister security component
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(SecCompManagerTest, UnregisterSecurityComponent001, TestSize.Level0)
431 {
432 SecCompCallerInfo caller = {
433 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
434 .pid = ServiceTestCommon::TEST_PID_1
435 };
436
437 ASSERT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
438 SecCompManager::GetInstance().UnregisterSecurityComponent(ServiceTestCommon::TEST_INVALID_SC_ID, caller));
439 }
440
441 /**
442 * @tc.name: ReportSecurityComponentClickEvent001
443 * @tc.desc: Test report security component click
444 * @tc.type: FUNC
445 * @tc.require:
446 */
447 HWTEST_F(SecCompManagerTest, ReportSecurityComponentClickEvent001, TestSize.Level0)
448 {
449 SecCompCallerInfo caller = {
450 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
451 .pid = ServiceTestCommon::TEST_PID_1
452 };
453 SecCompClickEvent clickInfo = {};
454 nlohmann::json jsonVaild;
455 LocationButton buttonValid = BuildValidLocationComponent();
456 buttonValid.ToJson(jsonVaild);
457 std::vector<sptr<IRemoteObject>> remote = { nullptr, nullptr };
458 int32_t scId = 1;
459 SecCompInfo secCompInfo{ scId, "", clickInfo};
460 std::string message;
461 ASSERT_NE(SC_OK, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(secCompInfo,
462 jsonVaild, caller, remote, message));
463 }
464
465 /**
466 * @tc.name: AddSecurityComponentToList004
467 * @tc.desc: Test add security component too many components
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList004, TestSize.Level0)
472 {
473 std::shared_ptr<SecCompManager> managerInstance = std::make_shared<SecCompManager>();
474 managerInstance->isSaExit_ = false;
475 int pid = 1;
476 std::shared_ptr<SecCompEntity> entity =
477 std::make_shared<SecCompEntity>(
478 nullptr, 0, 0, 1, 1);
479 const int MAX_COMPONENT_SIZE = 500;
480 for (int i = 0; i < MAX_COMPONENT_SIZE; i++) {
481 managerInstance->componentMap_[pid].compList.emplace_back(entity);
482 }
483
484 ASSERT_NE(managerInstance->AddSecurityComponentToList(pid, 0, entity), SC_SERVICE_ERROR_VALUE_INVALID);
485 }
486
487 /**
488 * @tc.name: CheckClickSecurityComponentInfo001
489 * @tc.desc: Test check click security component info failed
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(SecCompManagerTest, CheckClickSecurityComponentInfo001, TestSize.Level0)
494 {
495 SecCompCallerInfo caller = {
496 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
497 .pid = ServiceTestCommon::TEST_PID_1
498 };
499 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
500 ASSERT_NE(nullptr, compPtr);
501
502 std::shared_ptr<SecCompEntity> entity =
503 std::make_shared<SecCompEntity>(
504 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
505 ASSERT_EQ(SC_OK,
506 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
507
508 SecCompClickEvent clickInfo = {};
509 nlohmann::json jsonVaild;
510 LocationButton buttonValid = BuildValidLocationComponent();
511 buttonValid.ToJson(jsonVaild);
512 jsonVaild[JsonTagConstants::JSON_SC_TYPE] = UNKNOWN_SC_TYPE;
513 std::vector<sptr<IRemoteObject>> remote = { nullptr, nullptr };
514 SecCompInfo secCompInfo{ ServiceTestCommon::TEST_SC_ID_1, "", clickInfo };
515 std::string message;
516 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
517 secCompInfo, jsonVaild, caller, remote, message));
518
519 jsonVaild[JsonTagConstants::JSON_SC_TYPE] = LOCATION_COMPONENT;
520 jsonVaild[JsonTagConstants::JSON_RECT][JsonTagConstants::JSON_RECT_X] = ServiceTestCommon::TEST_INVALID_DIMENSION;
521 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
522 secCompInfo, jsonVaild, caller, remote, message));
523
524 jsonVaild[JsonTagConstants::JSON_RECT][JsonTagConstants::JSON_RECT_X] = ServiceTestCommon::TEST_COORDINATE - 1;
525 ASSERT_EQ(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().ReportSecurityComponentClickEvent(
526 secCompInfo, jsonVaild, caller, remote, message));
527 }
528
529 /**
530 * @tc.name: AddSecurityComponentToList003
531 * @tc.desc: Test add security component to list sa not exit
532 * @tc.type: FUNC
533 * @tc.require:
534 */
535 HWTEST_F(SecCompManagerTest, AddSecurityComponentToList003, TestSize.Level0)
536 {
537 SecCompManager::GetInstance().isSaExit_ = true;
538 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
539 std::shared_ptr<SecCompEntity> entity =
540 std::make_shared<SecCompEntity>(
541 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
542 ASSERT_EQ(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
543 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
544 SecCompManager::GetInstance().isSaExit_ = false;
545 }
546
547 /**
548 * @tc.name: DeleteSecurityComponentFromList002
549 * @tc.desc: Test delete security component
550 * @tc.type: FUNC
551 * @tc.require:
552 */
553 HWTEST_F(SecCompManagerTest, DeleteSecurityComponentFromList002, TestSize.Level0)
554 {
555 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
556 ASSERT_NE(nullptr, compPtr);
557 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
558 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
559 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
560 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
561 std::shared_ptr<SecCompEntity> entity =
562 std::make_shared<SecCompEntity>(
563 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
564 ASSERT_EQ(SC_OK,
565 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
566
567 auto component = SecCompManager::GetInstance().GetSecurityComponentFromList(1, 1);
568 ASSERT_NE(nullptr, component);
569 ASSERT_EQ(SC_OK, SecCompManager::GetInstance().DeleteSecurityComponentFromList(1, 1));
570 }
571
572 /**
573 * @tc.name: UpdateSecurityComponent002
574 * @tc.desc: Test update security component
575 * @tc.type: FUNC
576 * @tc.require:
577 */
578 HWTEST_F(SecCompManagerTest, UpdateSecurityComponent002, TestSize.Level0)
579 {
580 nlohmann::json jsonValid;
581 SecCompCallerInfo caller = {
582 .tokenId = ServiceTestCommon::TEST_TOKEN_ID,
583 .pid = ServiceTestCommon::TEST_PID_1
584 };
585 ASSERT_NE(SC_SERVICE_ERROR_COMPONENT_INFO_INVALID, SecCompManager::GetInstance().UpdateSecurityComponent(
586 ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
587
588 SecCompManager::GetInstance().malicious_.AddAppToMaliciousAppList(ServiceTestCommon::TEST_PID_1);
589 LocationButton buttonValid = BuildValidLocationComponent();
590 buttonValid.ToJson(jsonValid);
591 ASSERT_NE(SC_ENHANCE_ERROR_IN_MALICIOUS_LIST, SecCompManager::GetInstance().UpdateSecurityComponent(
592 ServiceTestCommon::TEST_SC_ID_1, jsonValid, caller));
593 }
594
595 /**
596 * @tc.name: ExitSaProcess001
597 * @tc.desc: Test check ExitSaProcess
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(SecCompManagerTest, ExitSaProcess001, TestSize.Level0)
602 {
603 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
604 ASSERT_NE(nullptr, compPtr);
605 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
606 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
607 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
608 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
609 std::shared_ptr<SecCompEntity> entity =
610 std::make_shared<SecCompEntity>(
611 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
612 std::shared_ptr<SecCompManager> instance = std::make_shared<SecCompManager>();
613 ASSERT_EQ(SC_OK,
614 instance->AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
615 instance->ExitSaProcess();
616 EXPECT_FALSE(instance->isSaExit_);
617
618 instance->componentMap_.clear();
619 instance->ExitSaProcess();
620 EXPECT_TRUE(instance->isSaExit_);
621 instance->isSaExit_ = false;
622
623 std::shared_ptr<SystemAbilityManagerClient> saClient = std::make_shared<SystemAbilityManagerClient>();
624 ASSERT_NE(nullptr, saClient);
625 SystemAbilityManagerClient::clientInstance = saClient.get();
626 sptr<SystemAbilityManagerProxy> proxy = new SystemAbilityManagerProxy(nullptr);
627 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
628 instance->ExitSaProcess();
629 EXPECT_TRUE(instance->isSaExit_);
630 instance->isSaExit_ = false;
631
632 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
633 EXPECT_CALL(*proxy, UnloadSystemAbility(testing::_)).WillOnce(testing::Return(-1));
634 instance->ExitSaProcess();
635 EXPECT_TRUE(instance->isSaExit_);
636 }
637
638 /**
639 * @tc.name: ExitWhenAppMgrDied001
640 * @tc.desc: Test check ExitWhenAppMgrDied
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(SecCompManagerTest, ExitWhenAppMgrDied001, TestSize.Level0)
645 {
646 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
647 ASSERT_NE(nullptr, compPtr);
648 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
649 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
650 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
651 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
652 std::shared_ptr<SecCompEntity> entity =
653 std::make_shared<SecCompEntity>(
654 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
655
656 std::shared_ptr<SystemAbilityManagerClient> saClient = std::make_shared<SystemAbilityManagerClient>();
657 ASSERT_NE(nullptr, saClient);
658 SystemAbilityManagerClient::clientInstance = saClient.get();
659
660 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(nullptr));
661 std::shared_ptr<SecCompManager> instance = std::make_shared<SecCompManager>();
662 EXPECT_EQ(SC_OK, instance->AddSecurityComponentToList(1, 0, entity));
663 instance->ExitWhenAppMgrDied();
664 EXPECT_TRUE(instance->isSaExit_);
665
666 sptr<SystemAbilityManagerProxy> proxy = new SystemAbilityManagerProxy(nullptr);
667 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
668 instance->ExitWhenAppMgrDied();
669 EXPECT_TRUE(instance->isSaExit_);
670
671 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
672 instance->ExitWhenAppMgrDied();
673 EXPECT_TRUE(instance->isSaExit_);
674
675 EXPECT_CALL(*saClient, GetSystemAbilityManager()).WillOnce(testing::Return(proxy));
676 EXPECT_CALL(*proxy, UnloadSystemAbility(testing::_)).WillOnce(testing::Return(-1));
677 instance->ExitWhenAppMgrDied();
678 EXPECT_TRUE(instance->isSaExit_);
679 }
680
681 /**
682 * @tc.name: SendCheckInfoEnhanceSysEvent001
683 * @tc.desc: Test check SendCheckInfoEnhanceSysEvent
684 * @tc.type: FUNC
685 * @tc.require:
686 */
687 HWTEST_F(SecCompManagerTest, SendCheckInfoEnhanceSysEvent001, TestSize.Level0)
688 {
689 SecCompManager::GetInstance().malicious_.maliciousAppList_.clear();
690 ASSERT_TRUE(SecCompManager::GetInstance().malicious_.IsMaliciousAppListEmpty());
691 int32_t scId = INVALID_SC_ID;
692 const std::string scene = "";
693 int32_t res = SC_ENHANCE_ERROR_CHALLENGE_CHECK_FAIL;
694 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
695 }
696
697 /**
698 * @tc.name: DumpSecComp001
699 * @tc.desc: Test check DumpSecComp
700 * @tc.type: FUNC
701 * @tc.require:
702 */
703 HWTEST_F(SecCompManagerTest, DumpSecComp001, TestSize.Level0)
704 {
705 std::shared_ptr<LocationButton> compPtr = std::make_shared<LocationButton>();
706 ASSERT_NE(nullptr, compPtr);
707 compPtr->rect_.x_ = ServiceTestCommon::TEST_COORDINATE;
708 compPtr->rect_.y_ = ServiceTestCommon::TEST_COORDINATE;
709 compPtr->rect_.width_ = ServiceTestCommon::TEST_COORDINATE;
710 compPtr->rect_.height_ = ServiceTestCommon::TEST_COORDINATE;
711 std::shared_ptr<SecCompEntity> entity =
712 std::make_shared<SecCompEntity>(
713 compPtr, ServiceTestCommon::TEST_TOKEN_ID, ServiceTestCommon::TEST_SC_ID_1, 1, 1);
714 SecCompManager::GetInstance().isSaExit_ = false;
715 ASSERT_EQ(SC_OK,
716 SecCompManager::GetInstance().AddSecurityComponentToList(ServiceTestCommon::TEST_PID_1, 0, entity));
717 std::string dumpStr;
718 SecCompManager::GetInstance().DumpSecComp(dumpStr);
719 }
720
721 /**
722 * @tc.name: TransformCallBackResult001
723 * @tc.desc: Test check TransformCallBackResult
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(SecCompManagerTest, TransformCallBackResult001, TestSize.Level0)
728 {
729 int32_t scId = INVALID_SC_ID;
730 const std::string scene = "REGISTER";
731 int32_t res = SC_ENHANCE_ERROR_NOT_EXIST_ENHANCE;
732 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
733 res = SC_ENHANCE_ERROR_VALUE_INVALID;
734 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
735 res = SC_ENHANCE_ERROR_CALLBACK_OPER_FAIL;
736 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
737 res = SC_SERVICE_ERROR_COMPONENT_INFO_INVALID;
738 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
739 res = SC_ENHANCE_ERROR_CALLBACK_CHECK_FAIL;
740 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
741 res = SC_SERVICE_ERROR_VALUE_INVALID;
742 SecCompManager::GetInstance().SendCheckInfoEnhanceSysEvent(scId, LOCATION_COMPONENT, scene, res);
743 }
744
745 /**
746 * @tc.name: AddSecurityComponentProcess001
747 * @tc.desc: Test AddSecurityComponentProcess
748 * @tc.type: FUNC
749 * @tc.require:
750 */
751 HWTEST_F(SecCompManagerTest, AddSecurityComponentProcess001, TestSize.Level0)
752 {
753 bool isSaExit = SecCompManager::GetInstance().isSaExit_;
754 SecCompManager::GetInstance().isSaExit_ = true;
755 SecCompCallerInfo info = {
756 .pid = 0,
757 .tokenId = 0,
758 .uid = 0,
759 };
760 EXPECT_EQ(SC_SERVICE_ERROR_SERVICE_NOT_EXIST,
761 SecCompManager::GetInstance().AddSecurityComponentProcess(info));
762 auto oldmap = SecCompManager::GetInstance().componentMap_;
763 SecCompManager::GetInstance().componentMap_.clear();
764 SecCompManager::GetInstance().isSaExit_ = false;
765 EXPECT_EQ(SC_OK, SecCompManager::GetInstance().AddSecurityComponentProcess(info));
766 SecCompManager::GetInstance().componentMap_ = oldmap;
767 SecCompManager::GetInstance().isSaExit_ = isSaExit;
768 }