1 /*
2 * Copyright (c) 2023 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 #include "sec_comp_service_mock_test.h"
16
17 #include "accesstoken_kit.h"
18 #include "ipc_skeleton.h"
19 #include "iservice_registry.h"
20 #include "location_button.h"
21 #include "paste_button.h"
22 #include "save_button.h"
23 #include "sec_comp_client.h"
24 #include "sec_comp_err.h"
25 #include "sec_comp_info.h"
26 #include "sec_comp_log.h"
27 #include "sec_comp_tool.h"
28 #include "sec_comp_enhance_adapter.h"
29 #include "service_test_common.h"
30 #include "system_ability.h"
31 #include "token_setproc.h"
32 #include "window_manager.h"
33
34 using namespace testing::ext;
35 using namespace OHOS;
36 using namespace OHOS::Security::SecurityComponent;
37 using namespace OHOS::Security::AccessToken;
38
39 namespace {
40 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
41 LOG_CORE, SECURITY_DOMAIN_SECURITY_COMPONENT, "SecCompServiceMockTest"};
42 static AccessTokenID g_selfTokenId = 0;
43 }
44
SetUpTestCase()45 void SecCompServiceMockTest::SetUpTestCase()
46 {}
47
TearDownTestCase()48 void SecCompServiceMockTest::TearDownTestCase()
49 {}
50
SetUp()51 void SecCompServiceMockTest::SetUp()
52 {
53 SC_LOG_INFO(LABEL, "setup");
54 if (secCompService_ != nullptr) {
55 return;
56 }
57 SecCompService* ptr = new (std::nothrow) SecCompService(ServiceTestCommon::SA_ID, true);
58 secCompService_ = sptr<SecCompService>(ptr);
59 ASSERT_NE(nullptr, secCompService_);
60 secCompService_->appStateObserver_ = new (std::nothrow) AppStateObserver();
61 ASSERT_NE(nullptr, secCompService_->appStateObserver_);
62 g_selfTokenId = GetSelfTokenID();
63
64 Rosen::WindowManager::GetInstance().SetDefaultSecCompScene();
65 }
66
TearDown()67 void SecCompServiceMockTest::TearDown()
68 {
69 if (secCompService_ != nullptr) {
70 secCompService_->appStateObserver_ = nullptr;
71 }
72 secCompService_ = nullptr;
73 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
74 }
75
76 /**
77 * @tc.name: WriteError001
78 * @tc.desc: Test WriteError
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(SecCompServiceMockTest, WriteError001, TestSize.Level0)
83 {
84 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
85 secCompService_->Initialize();
86 SecCompRawdata rawReply;
87 EXPECT_EQ(SC_OK, secCompService_->WriteError(SC_SERVICE_ERROR_VALUE_INVALID, rawReply));
88 }
89
90 /**
91 * @tc.name: RegisterReadFromRawdata001
92 * @tc.desc: Test register read from rawdata
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(SecCompServiceMockTest, RegisterReadFromRawdata001, TestSize.Level0)
97 {
98 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
99 secCompService_->Initialize();
100 MessageParcel data;
101 SecCompType type;
102 std::string outComponentInfo;
103 uint32_t uintType;
104 std::string componentInfo;
105
106 // rawdata.data is nullptr
107 SecCompRawdata rawdataVoid;
108 rawdataVoid.size = 1;
109 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
110 secCompService_->RegisterReadFromRawdata(rawdataVoid, type, outComponentInfo));
111
112 // Type is UNKONWN_SC_TYPE
113 uintType = 0;
114 data.WriteUint32(uintType);
115 data.WriteString(componentInfo);
116 SecCompRawdata rawdataSmallType;
117 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataSmallType));
118 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
119 secCompService_->RegisterReadFromRawdata(rawdataSmallType, type, outComponentInfo));
120 data.FlushBuffer();
121
122 // Type is bigger than MAX_SC_TYPE
123 uintType = 100;
124 data.WriteUint32(uintType);
125 data.WriteString(componentInfo);
126 SecCompRawdata rawdataBigType;
127 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBigType));
128 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
129 secCompService_->RegisterReadFromRawdata(rawdataBigType, type, outComponentInfo));
130 data.FlushBuffer();
131
132 // register read from rawdata OK
133 uintType = SAVE_COMPONENT;
134 data.WriteUint32(uintType);
135 data.WriteString(componentInfo);
136 SecCompRawdata rawdataValidType;
137 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataValidType));
138 EXPECT_EQ(SC_OK, secCompService_->RegisterReadFromRawdata(rawdataValidType, type, outComponentInfo));
139 EXPECT_EQ(SAVE_COMPONENT, type);
140 }
141
142 /**
143 * @tc.name: RegisterSecurityComponentBody001
144 * @tc.desc: Test register security component
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody001, TestSize.Level0)
149 {
150 // get caller fail
151 int32_t scId;
152 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
153 secCompService_->Initialize();
154 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, "", scId));
155 nlohmann::json jsonRes;
156 ServiceTestCommon::BuildSaveComponentJson(jsonRes);
157 std::string saveInfo = jsonRes.dump();
158
159 // parse component json fail
160 ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
161 AppExecFwk::AppStateData stateData = {
162 .uid = getuid()
163 };
164 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
165 // wrong json
166 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
167 secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, "{a=", scId));
168
169 // register security component ok
170 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, saveInfo, scId));
171 EXPECT_EQ(SC_OK, secCompService_->UpdateSecurityComponentBody(scId, saveInfo));
172 uint8_t buffer[1] = { 0 };
173 struct SecCompClickEvent touch = {
174 .type = ClickEventType::POINT_EVENT_TYPE,
175 .point.touchX = 100,
176 .point.touchY = 100,
177 .point.timestamp =
178 static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
179 ServiceTestCommon::TIME_CONVERSION_UNIT,
180 .extraInfo = {
181 .data = buffer,
182 .dataSize = 1
183 },
184 };
185 SecCompInfo secCompInfo{ scId, saveInfo, touch };
186 std::string message;
187 EXPECT_EQ(SC_OK, secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
188 EXPECT_EQ(SC_OK, secCompService_->UnregisterSecurityComponentBody(scId));
189 SecCompPermManager::GetInstance().applySaveCountMap_.clear();
190 }
191
192 /**
193 * @tc.name: RegisterSecurityComponentBody002
194 * @tc.desc: Test register security component check touch info failed
195 * @tc.type: FUNC
196 * @tc.require:
197 */
198 HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody002, TestSize.Level0)
199 {
200 int32_t scId;
201 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
202 secCompService_->Initialize();
203 nlohmann::json jsonRes;
204 ServiceTestCommon::BuildSaveComponentJson(jsonRes);
205 std::string saveInfo = jsonRes.dump();
206
207 ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
208 AppExecFwk::AppStateData stateData = {
209 .uid = getuid()
210 };
211 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
212 // register security component ok
213 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, saveInfo, scId));
214 struct SecCompClickEvent touch = {
215 .type = ClickEventType::POINT_EVENT_TYPE,
216 .point.touchX = 100,
217 .point.touchY = 100,
218 .point.timestamp = static_cast<uint64_t>(
219 std::chrono::high_resolution_clock::now().time_since_epoch().count())
220 };
221 SecCompInfo secCompInfo{ scId, saveInfo, touch };
222 std::string message;
223 EXPECT_EQ(SC_SERVICE_ERROR_CLICK_EVENT_INVALID,
224 secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
225 EXPECT_EQ(SC_OK, secCompService_->UnregisterSecurityComponentBody(scId));
226 SecCompPermManager::GetInstance().applySaveCountMap_.clear();
227 }
228
229 /**
230 * @tc.name: RegisterSecurityComponentBody003
231 * @tc.desc: Test register security component permission grant failed
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody003, TestSize.Level0)
236 {
237 int32_t scId;
238 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
239 secCompService_->Initialize();
240 nlohmann::json jsonRes;
241 ServiceTestCommon::BuildSaveComponentJson(jsonRes);
242 std::string saveInfo = jsonRes.dump();
243
244 ASSERT_EQ(0, SetSelfTokenID(0));
245 AppExecFwk::AppStateData stateData = {
246 .uid = getuid()
247 };
248 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
249 // register security component ok
250 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, saveInfo, scId));
251 uint8_t buffer[1] = { 0 };
252 struct SecCompClickEvent touch = {
253 .type = ClickEventType::POINT_EVENT_TYPE,
254 .point.touchX = 100,
255 .point.touchY = 100,
256 .point.timestamp =
257 static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
258 ServiceTestCommon::TIME_CONVERSION_UNIT,
259 .extraInfo = {
260 .data = buffer,
261 .dataSize = 1
262 },
263 };
264 SecCompInfo secCompInfo{ scId, saveInfo, touch };
265 std::string message;
266 EXPECT_EQ(SC_SERVICE_ERROR_PERMISSION_OPER_FAIL,
267 secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
268 EXPECT_EQ(SC_OK, secCompService_->UnregisterSecurityComponentBody(scId));
269 SecCompPermManager::GetInstance().applySaveCountMap_.clear();
270 }
271
272 /**
273 * @tc.name: RegisterWriteToRawdata001
274 * @tc.desc: Test register write to rawdata
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 HWTEST_F(SecCompServiceMockTest, RegisterWriteToRawdata001, TestSize.Level0)
279 {
280 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
281 secCompService_->Initialize();
282 int32_t scId = 1;
283 int32_t res = SC_OK;
284 SecCompRawdata rawReply;
285 EXPECT_EQ(SC_OK, secCompService_->RegisterWriteToRawdata(res, scId, rawReply));
286 }
287
288 /**
289 * @tc.name: RegisterSecurityComponent001
290 * @tc.desc: Test register security component
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent001, TestSize.Level0)
295 {
296 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
297 secCompService_->Initialize();
298 MessageParcel data;
299 uint32_t uintType;
300
301 // RegisterReadFromRawdata fail
302 SecCompRawdata rawdataVoid;
303 rawdataVoid.size = 1;
304 SecCompRawdata rawReplyReadFail;
305 MessageParcel replyReadFail;
306 EXPECT_EQ(SC_OK,
307 secCompService_->RegisterSecurityComponent(rawdataVoid, rawReplyReadFail));
308 SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyReadFail, replyReadFail);
309 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyReadFail.ReadInt32());
310
311 // RegisterSecurityComponentBody fail
312 uintType = SAVE_COMPONENT;
313 data.WriteUint32(uintType);
314 data.WriteString("");
315 SecCompRawdata rawdataBodyFail;
316 SecCompRawdata rawReplyBodyFail;
317 MessageParcel replyBodyFail;
318 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
319 EXPECT_EQ(SC_OK,
320 secCompService_->RegisterSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
321 SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail);
322 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyBodyFail.ReadInt32());
323 data.FlushBuffer();
324
325 // RegisterSecurityComponent OK
326 nlohmann::json jsonRes;
327 ServiceTestCommon::BuildSaveComponentJson(jsonRes);
328 std::string saveInfo = jsonRes.dump();
329 uintType = SAVE_COMPONENT;
330 data.WriteUint32(uintType);
331 data.WriteString(saveInfo);
332 SecCompRawdata rawdata;
333 SecCompRawdata rawReply;
334 MessageParcel reply;
335 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
336 EXPECT_EQ(SC_OK,
337 secCompService_->RegisterSecurityComponent(rawdata, rawReply));
338 SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply);
339 EXPECT_EQ(SC_OK, reply.ReadInt32());
340 }
341
342 /**
343 * @tc.name: UpdateReadFromRawdata001
344 * @tc.desc: Test UpdateReadFromRawdata
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(SecCompServiceMockTest, UpdateReadFromRawdata001, TestSize.Level0)
349 {
350 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
351 secCompService_->Initialize();
352 MessageParcel data;
353 int32_t scIdOut;
354 std::string componentInfoOut;
355
356 // rawdata.data is nullptr
357 SecCompRawdata rawdataVoid;
358 rawdataVoid.size = 1;
359 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
360 secCompService_->UpdateReadFromRawdata(rawdataVoid, scIdOut, componentInfoOut));
361
362 // scId is invalid
363 data.WriteInt32(-1);
364 SecCompRawdata rawdataScidInvalid;
365 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
366 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
367 secCompService_->UpdateReadFromRawdata(rawdataScidInvalid, scIdOut, componentInfoOut));
368 data.FlushBuffer();
369
370 // UpdateReadFromRawdata OK
371 data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
372 data.WriteString("");
373 SecCompRawdata rawdata;
374 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
375 EXPECT_EQ(SC_OK,
376 secCompService_->UpdateReadFromRawdata(rawdata, scIdOut, componentInfoOut));
377 data.FlushBuffer();
378 }
379
380 /**
381 * @tc.name: UpdateWriteToRawdata001
382 * @tc.desc: Test UpdateWriteToRawdata
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(SecCompServiceMockTest, UpdateWriteToRawdata001, TestSize.Level0)
387 {
388 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
389 secCompService_->Initialize();
390 SecCompRawdata rawReply;
391 EXPECT_EQ(SC_OK,
392 secCompService_->UpdateWriteToRawdata(SC_OK, rawReply));
393 }
394
395 /**
396 * @tc.name: UpdateSecurityComponent001
397 * @tc.desc: Test UpdateSecurityComponent fail
398 * @tc.type: FUNC
399 * @tc.require:
400 */
401 HWTEST_F(SecCompServiceMockTest, UpdateSecurityComponent001, TestSize.Level0)
402 {
403 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
404 secCompService_->Initialize();
405 MessageParcel data;
406
407 // UpdateReadFromRawdata from fail
408 SecCompRawdata rawdataVoid;
409 rawdataVoid.size = 1;
410 SecCompRawdata rawReplyVoid;
411 MessageParcel replyVoid;
412 EXPECT_EQ(SC_OK,
413 secCompService_->UpdateSecurityComponent(rawdataVoid, rawReplyVoid));
414 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
415 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
416
417 // UpdateSecurityComponentBody fail
418 SecCompRawdata rawdataBodyFail;
419 SecCompRawdata rawReplyBodyFail;
420 MessageParcel replyBodyFail;
421 data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
422 data.WriteString("");
423 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
424 EXPECT_EQ(SC_OK,
425 secCompService_->UpdateSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
426 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail));
427 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyBodyFail.ReadInt32());
428 data.FlushBuffer();
429 }
430
431 /**
432 * @tc.name: UpdateSecurityComponent002
433 * @tc.desc: Test UpdateSecurityComponent OK
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(SecCompServiceMockTest, UpdateSecurityComponent002, TestSize.Level0)
438 {
439 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
440 secCompService_->Initialize();
441 MessageParcel data;
442 nlohmann::json jsonRes;
443 ServiceTestCommon::BuildLocationComponentJson(jsonRes);
444 std::string locationInfo = jsonRes.dump();
445 int32_t scId;
446 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(
447 LOCATION_COMPONENT, locationInfo, scId));
448
449 SecCompRawdata rawdata;
450 SecCompRawdata rawReply;
451 MessageParcel reply;
452 data.WriteInt32(scId);
453 data.WriteString(locationInfo);
454 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
455 EXPECT_EQ(SC_OK,
456 secCompService_->UpdateSecurityComponent(rawdata, rawReply));
457 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
458 EXPECT_EQ(SC_OK, reply.ReadInt32());
459 }
460
461 /**
462 * @tc.name: UnregisterReadFromRawdata001
463 * @tc.desc: Test UnregisterReadFromRawdata
464 * @tc.type: FUNC
465 * @tc.require:
466 */
467 HWTEST_F(SecCompServiceMockTest, UnregisterReadFromRawdata001, TestSize.Level0)
468 {
469 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
470 secCompService_->Initialize();
471 MessageParcel data;
472 int32_t scIdOut;
473 std::string componentInfoOut;
474
475 // rawdata.data is nullptr
476 SecCompRawdata rawdataVoid;
477 rawdataVoid.size = 1;
478 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
479 secCompService_->UnregisterReadFromRawdata(rawdataVoid, scIdOut));
480
481 // scId is invalid
482 data.WriteInt32(-1);
483 SecCompRawdata rawdataScidInvalid;
484 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
485 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
486 secCompService_->UnregisterReadFromRawdata(rawdataScidInvalid, scIdOut));
487 data.FlushBuffer();
488
489 // UpdateReadFromRawdata OK
490 data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
491 SecCompRawdata rawdata;
492 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
493 EXPECT_EQ(SC_OK,
494 secCompService_->UnregisterReadFromRawdata(rawdata, scIdOut));
495 EXPECT_EQ(ServiceTestCommon::TEST_SC_ID_1, scIdOut);
496 data.FlushBuffer();
497 }
498
499 /**
500 * @tc.name: UnregisterWriteToRawdata001
501 * @tc.desc: Test UnregisterWriteToRawdata
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(SecCompServiceMockTest, UnregisterWriteToRawdata001, TestSize.Level0)
506 {
507 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
508 secCompService_->Initialize();
509 SecCompRawdata rawReply;
510 EXPECT_EQ(SC_OK,
511 secCompService_->UnregisterWriteToRawdata(SC_OK, rawReply));
512 }
513
514 /**
515 * @tc.name: UnregisterSecurityComponent001
516 * @tc.desc: Test UnregisterSecurityComponent fail
517 * @tc.type: FUNC
518 * @tc.require:
519 */
520 HWTEST_F(SecCompServiceMockTest, UnregisterSecurityComponent001, TestSize.Level0)
521 {
522 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
523 secCompService_->Initialize();
524 MessageParcel data;
525
526 // UnregisterReadFromRawdata fail
527 SecCompRawdata rawdataVoid;
528 rawdataVoid.size = 1;
529 SecCompRawdata rawReplyVoid;
530 MessageParcel replyVoid;
531 EXPECT_EQ(SC_OK,
532 secCompService_->UnregisterSecurityComponent(rawdataVoid, rawReplyVoid));
533 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
534 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
535
536 // UpdateSecurityComponentBody fail
537 SecCompRawdata rawdataBodyFail;
538 SecCompRawdata rawReplyBodyFail;
539 MessageParcel replyBodyFail;
540 data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
541 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
542 EXPECT_EQ(SC_OK,
543 secCompService_->UnregisterSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
544 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail));
545 EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, replyBodyFail.ReadInt32());
546 }
547
548 /**
549 * @tc.name: UnregisterSecurityComponent002
550 * @tc.desc: Test UnregisterSecurityComponent OK
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 HWTEST_F(SecCompServiceMockTest, UnregisterSecurityComponent002, TestSize.Level0)
555 {
556 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
557 secCompService_->Initialize();
558 MessageParcel data;
559 nlohmann::json jsonRes;
560 ServiceTestCommon::BuildLocationComponentJson(jsonRes);
561 std::string locationInfo = jsonRes.dump();
562 int32_t scId;
563 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(
564 LOCATION_COMPONENT, locationInfo, scId));
565
566 SecCompRawdata rawdata;
567 SecCompRawdata rawReply;
568 MessageParcel reply;
569 data.WriteInt32(scId);
570 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
571 EXPECT_EQ(SC_OK,
572 secCompService_->UnregisterSecurityComponent(rawdata, rawReply));
573 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
574 EXPECT_EQ(SC_OK, reply.ReadInt32());
575 }
576
577 /**
578 * @tc.name: PreRegisterReadFromRawdata001
579 * @tc.desc: Test PreRegisterReadFromRawdata
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(SecCompServiceMockTest, PreRegisterReadFromRawdata001, TestSize.Level0)
584 {
585 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
586 secCompService_->Initialize();
587 MessageParcel data;
588
589 // rawdata.data is nullptr
590 SecCompRawdata rawdataVoid;
591 rawdataVoid.size = 1;
592 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
593 secCompService_->PreRegisterReadFromRawdata(rawdataVoid));
594
595 // PreRegisterReadFromRawdata OK
596 SecCompRawdata rawdata;
597 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
598 EXPECT_EQ(SC_OK,
599 secCompService_->PreRegisterReadFromRawdata(rawdata));
600 }
601
602 /**
603 * @tc.name: PreRegisterWriteToRawdata001
604 * @tc.desc: Test PreRegisterWriteToRawdata
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(SecCompServiceMockTest, PreRegisterWriteToRawdata001, TestSize.Level0)
609 {
610 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
611 secCompService_->Initialize();
612 SecCompRawdata rawReply;
613 EXPECT_EQ(SC_OK,
614 secCompService_->PreRegisterWriteToRawdata(SC_OK, rawReply));
615 }
616
617 /**
618 * @tc.name: PreRegisterSecCompProcess001
619 * @tc.desc: Test PreRegisterSecCompProcess
620 * @tc.type: FUNC
621 * @tc.require:
622 */
623 HWTEST_F(SecCompServiceMockTest, PreRegisterSecCompProcess001, TestSize.Level0)
624 {
625 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
626 secCompService_->Initialize();
627 MessageParcel data;
628
629 // UnregisterReadFromRawdata fail
630 SecCompRawdata rawdataVoid;
631 rawdataVoid.size = 1;
632 SecCompRawdata rawReplyVoid;
633 MessageParcel replyVoid;
634 EXPECT_EQ(SC_OK,
635 secCompService_->PreRegisterSecCompProcess(rawdataVoid, rawReplyVoid));
636 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
637 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
638
639 // UnregisterReadFromRawdata OK
640 SecCompRawdata rawdata;
641 SecCompRawdata rawReply;
642 MessageParcel reply;
643 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
644 EXPECT_EQ(SC_OK,
645 secCompService_->PreRegisterSecCompProcess(rawdata, rawReply));
646 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
647 EXPECT_EQ(SC_OK, reply.ReadInt32());
648 }
649
650 /**
651 * @tc.name: ReportSecurityComponentClickEventBody001
652 * @tc.desc: Test register security component
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEventBody001, TestSize.Level1)
657 {
658 int32_t scId;
659 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
660 secCompService_->Initialize();
661 nlohmann::json jsonRes;
662 ServiceTestCommon::BuildSaveComponentJson(jsonRes);
663 std::string saveInfo = jsonRes.dump();
664
665 ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
666 AppExecFwk::AppStateData stateData = {
667 .uid = getuid()
668 };
669 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
670 // register security component ok
671 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(SAVE_COMPONENT, saveInfo, scId));
672 uint8_t buffer[1] = { 0 };
673 struct SecCompClickEvent clickInfo = {
674 .type = ClickEventType::POINT_EVENT_TYPE,
675 .point.touchX = 100,
676 .point.touchY = 100,
677 .point.timestamp =
678 static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
679 ServiceTestCommon::TIME_CONVERSION_UNIT,
680 .extraInfo = {
681 .data = buffer,
682 .dataSize = 1
683 },
684 };
685 SecCompInfo secCompInfo{ scId, saveInfo, clickInfo };
686 std::string message;
687 ASSERT_EQ(SC_OK, secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
688
689 // test 10s valid
690 bool isGranted;
691 secCompService_->VerifySavePermission(ServiceTestCommon::HAP_TOKEN_ID, isGranted);
692 ASSERT_TRUE(isGranted);
693 secCompService_->VerifySavePermission(ServiceTestCommon::HAP_TOKEN_ID, isGranted);
694 ASSERT_TRUE(isGranted);
695 sleep(61);
696 secCompService_->VerifySavePermission(ServiceTestCommon::HAP_TOKEN_ID, isGranted);
697 ASSERT_FALSE(isGranted);
698
699 // test 10s multiple clicks
700 secCompInfo.clickInfo.point.timestamp = static_cast<uint64_t>(
701 std::chrono::high_resolution_clock::now().time_since_epoch().count()) / ServiceTestCommon::TIME_CONVERSION_UNIT;
702 ASSERT_EQ(SC_OK, secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
703 sleep(3);
704 secCompInfo.clickInfo.point.timestamp = static_cast<uint64_t>(
705 std::chrono::high_resolution_clock::now().time_since_epoch().count()) / ServiceTestCommon::TIME_CONVERSION_UNIT;
706 ASSERT_EQ(SC_OK, secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
707 sleep(8);
708 secCompService_->VerifySavePermission(ServiceTestCommon::HAP_TOKEN_ID, isGranted);
709 ASSERT_TRUE(isGranted);
710 sleep(2);
711 EXPECT_EQ(SC_OK, secCompService_->UnregisterSecurityComponentBody(scId));
712 }
713
714 /**
715 * @tc.name: ReportSecurityComponentClickEventBody002
716 * @tc.desc: Test verify location permission
717 * @tc.type: FUNC
718 * @tc.require:
719 */
720 HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEventBody002, TestSize.Level0)
721 {
722 SC_LOG_INFO(LABEL, "ReportSecurityComponentClickEventBody002");
723 int32_t scId;
724 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
725 secCompService_->Initialize();
726 nlohmann::json jsonRes;
727 ServiceTestCommon::BuildLocationComponentJson(jsonRes);
728 std::string locationInfo = jsonRes.dump();
729
730 ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
731 AppExecFwk::AppStateData stateData = {
732 .uid = getuid()
733 };
734 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
735 // register security component ok
736 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(LOCATION_COMPONENT, locationInfo, scId));
737 uint8_t buffer[1] = { 0 };
738 struct SecCompClickEvent clickInfo1 = {
739 .type = ClickEventType::POINT_EVENT_TYPE,
740 .point.touchX = 100,
741 .point.touchY = 100,
742 .point.timestamp =
743 static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
744 ServiceTestCommon::TIME_CONVERSION_UNIT,
745 .extraInfo = {
746 .data = buffer,
747 .dataSize = 1
748 },
749 };
750 SecCompInfo secCompInfo{ scId, locationInfo, clickInfo1 };
751 std::string message;
752 ASSERT_EQ(SC_OK,
753 secCompService_->ReportSecurityComponentClickEventBody(secCompInfo, nullptr, nullptr, message));
754
755 // test 10s valid
756 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID, "ohos.permission.LOCATION"), 0);
757 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID,
758 "ohos.permission.APPROXIMATELY_LOCATION"), 0);
759 sleep(11);
760 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID, "ohos.permission.LOCATION"), 0);
761 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID,
762 "ohos.permission.APPROXIMATELY_LOCATION"), 0);
763
764 SecCompManager::GetInstance().NotifyProcessBackground(getpid());
765 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID, "ohos.permission.LOCATION"), 0);
766 ASSERT_EQ(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID,
767 "ohos.permission.APPROXIMATELY_LOCATION"), 0);
768 sleep(11);
769 ASSERT_NE(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID, "ohos.permission.LOCATION"), 0);
770 ASSERT_NE(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID,
771 "ohos.permission.APPROXIMATELY_LOCATION"), 0);
772 }
773
774 /**
775 * @tc.name: ReportSecurityComponentClickEvent001
776 * @tc.desc: Test ReportSecurityComponentClickEvent read rawData fail
777 * @tc.type: FUNC
778 * @tc.require:
779 */
780 HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent001, TestSize.Level0)
781 {
782 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
783 secCompService_->Initialize();
784 MessageParcel data;
785
786 // rawdata.data is nullptr
787 SecCompRawdata rawdataVoid;
788 SecCompRawdata rawReplyVoid;
789 MessageParcel replyVoid;
790 EXPECT_EQ(SC_OK,
791 secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdataVoid, rawReplyVoid));
792 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
793 EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
794
795 // scId is invalid
796 data.WriteInt32(-1);
797 SecCompRawdata rawdataScidInvalid;
798 SecCompRawdata rawReplyScidInvalid;
799 MessageParcel replyScidInvalid;
800 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
801 EXPECT_EQ(SC_OK,
802 secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdataScidInvalid, rawReplyScidInvalid));
803 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyScidInvalid, replyScidInvalid));
804 EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyScidInvalid.ReadInt32());
805 }
806
807 /**
808 * @tc.name: ReportSecurityComponentClickEvent002
809 * @tc.desc: Test ReportSecurityComponentClickEvent OK
810 * @tc.type: FUNC
811 * @tc.require:
812 */
813 HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent002, TestSize.Level0)
814 {
815 int32_t scId;
816 secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
817 secCompService_->Initialize();
818 nlohmann::json jsonRes;
819 ServiceTestCommon::BuildLocationComponentJson(jsonRes);
820 std::string locationInfo = jsonRes.dump();
821
822 ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
823 AppExecFwk::AppStateData stateData = {
824 .uid = getuid()
825 };
826 secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
827 // register security component ok
828 EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(LOCATION_COMPONENT, locationInfo, scId));
829 uint8_t buffer[1] = { 0 };
830 struct SecCompClickEvent clickInfo1 = {
831 .type = ClickEventType::POINT_EVENT_TYPE,
832 .point.touchX = 100,
833 .point.touchY = 100,
834 .point.timestamp =
835 static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
836 ServiceTestCommon::TIME_CONVERSION_UNIT,
837 .extraInfo = {
838 .data = buffer,
839 .dataSize = 1
840 },
841 };
842 SecCompInfo secCompInfo{ scId, locationInfo, clickInfo1 };
843
844 MessageParcel data;
845 data.WriteInt32(scId);
846 data.WriteString(locationInfo);
847 std::string message = "";
848 data.WriteString(message);
849 sptr<SecCompClickEventParcel> parcel = new (std::nothrow) SecCompClickEventParcel();
850 ASSERT_NE(nullptr, parcel);
851 parcel->clickInfoParams_ = clickInfo1;
852 data.WriteParcelable(parcel);
853
854 SecCompRawdata rawdata;
855 SecCompRawdata rawReply;
856 MessageParcel reply;
857 EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
858 EXPECT_EQ(SC_OK,
859 secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdata, rawReply));
860 ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
861 EXPECT_EQ(SC_OK, reply.ReadInt32());
862 }
863