1 /*
2 * Copyright (c) 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 "security_collector_test.h"
17
18 #include <thread>
19
20 #include "directory_ex.h"
21 #include "file_ex.h"
22 #include "gmock/gmock.h"
23 #include "system_ability_definition.h"
24
25 #include "security_guard_define.h"
26 #include "security_guard_log.h"
27 #include "security_guard_utils.h"
28 #define private public
29 #define protected public
30 #include "data_collection.h"
31 #include "collector_cfg_marshalling.h"
32 #include "accesstoken_kit.h"
33 #include "security_collector_manager_service.h"
34 #include "security_collector_run_manager.h"
35 #undef private
36 #undef protected
37
38 using namespace testing;
39 using namespace testing::ext;
40 using namespace OHOS::Security::SecurityGuard;
41 using namespace OHOS::Security::SecurityCollector;
42
43 namespace OHOS {
44 std::shared_ptr<Security::AccessToken::MockAccessTokenKitInterface>
45 Security::AccessToken::AccessTokenKit::instance_ = nullptr;
46 std::shared_ptr<Security::AccessToken::MockTokenIdKitInterface>
47 Security::AccessToken::TokenIdKit::instance_ = nullptr;
48 std::mutex Security::AccessToken::AccessTokenKit::mutex_ {};
49 std::mutex Security::AccessToken::TokenIdKit::mutex_ {};
50 constexpr char PERMISSION[] = "ohos.permission.securityguard.REQUEST_SECURITY_EVENT_INFO";
51 }
52
53 namespace OHOS::Security::SecurityCollectorTest {
54 SecurityCollectorManagerService g_service(SECURITY_COLLECTOR_MANAGER_SA_ID, true);
SetUpTestCase()55 void SecurityCollectorTest::SetUpTestCase()
56 {
57 }
58
TearDownTestCase()59 void SecurityCollectorTest::TearDownTestCase()
60 {
61 AccessToken::AccessTokenKit::DelInterface();
62 AccessToken::TokenIdKit::DelInterface();
63 }
64
SetUp()65 void SecurityCollectorTest::SetUp()
66 {
67 }
68
TearDown()69 void SecurityCollectorTest::TearDown()
70 {
71 }
72
73 class MockRemoteObject final : public IRemoteObject {
74 public:
MockRemoteObject()75 MockRemoteObject() : IRemoteObject(u"")
76 {
77 }
78 MOCK_METHOD0(GetObjectRefCount, int32_t());
79 MOCK_METHOD4(SendRequest, int(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option));
80 MOCK_METHOD1(AddDeathRecipient, bool(const sptr<DeathRecipient> &recipient));
81 MOCK_METHOD1(RemoveDeathRecipient, bool(const sptr<DeathRecipient> &recipient));
82 MOCK_METHOD2(Dump, int(int fd, const std::vector<std::u16string> &args));
83 };
84
85 HWTEST_F(SecurityCollectorTest, GetAppName01, TestSize.Level1)
86 {
87 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
88 Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
89 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
90 Return(SecurityCollector::ErrorCode::FAILED));
91 EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
92 }
93
94 HWTEST_F(SecurityCollectorTest, GetAppName02, TestSize.Level1)
95 {
96 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
97 Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
98 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillRepeatedly(
__anon2f99d3e50102(AccessToken::AccessTokenID tokenID, AccessToken::HapTokenInfo& hapTokenInfoRes) 99 [] (AccessToken::AccessTokenID tokenID, AccessToken::HapTokenInfo& hapTokenInfoRes) {
100 hapTokenInfoRes.bundleName = "bundleName";
101 return SecurityCollector::ErrorCode::SUCCESS;
102 });
103 EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "bundleName");
104 }
105
106 HWTEST_F(SecurityCollectorTest, GetAppName03, TestSize.Level1)
107 {
108 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
109 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
110 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
111 Return(SecurityCollector::ErrorCode::FAILED));
112 EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
113 }
114
115 HWTEST_F(SecurityCollectorTest, GetAppName04, TestSize.Level1)
116 {
117 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
118 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
119 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anon2f99d3e50202(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 120 [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
121 nativeTokenInfoRes.processName = "processName";
122 return SecurityCollector::ErrorCode::SUCCESS;
123 });
124 EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "processName");
125 }
126
127 HWTEST_F(SecurityCollectorTest, GetAppName05, TestSize.Level1)
128 {
129 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillRepeatedly(
130 Return(AccessToken::ATokenTypeEnum::TOKEN_INVALID));
131 EXPECT_EQ(SecurityCollectorManagerService::GetAppName(), "");
132 }
133
134 HWTEST_F(SecurityCollectorTest, HasPermission01, TestSize.Level1)
135 {
136 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
137 Return(AccessToken::PermissionState::PERMISSION_DENIED));
138 EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::NO_PERMISSION);
139 }
140
141 HWTEST_F(SecurityCollectorTest, HasPermission02, TestSize.Level1)
142 {
143 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
144 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
145 EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::SUCCESS);
146 }
147
148 HWTEST_F(SecurityCollectorTest, HasPermission03, TestSize.Level1)
149 {
150 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
151 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
152 EXPECT_EQ(SecurityCollectorManagerService::HasPermission(PERMISSION), SecurityCollector::ErrorCode::SUCCESS);
153 }
154
155 HWTEST_F(SecurityCollectorTest, Subscribe01, TestSize.Level1)
156 {
157 SecurityCollectorSubscribeInfo subscribeInfo{};
158 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
159 EXPECT_TRUE(obj != nullptr);
160 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
161 Return(AccessToken::PermissionState::PERMISSION_DENIED));
162 EXPECT_EQ(g_service.Subscribe(subscribeInfo, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
163 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
164 }
165
166 HWTEST_F(SecurityCollectorTest, Unsubscribe01, TestSize.Level1)
167 {
168 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
169 EXPECT_TRUE(obj != nullptr);
170 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
171 Return(AccessToken::PermissionState::PERMISSION_DENIED));
172 EXPECT_EQ(g_service.Unsubscribe(obj), SecurityCollector::ErrorCode::NO_PERMISSION);
173 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
174 }
175
176 HWTEST_F(SecurityCollectorTest, CollectorStart01, TestSize.Level1)
177 {
178 SecurityCollectorSubscribeInfo info{};
179 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
180 EXPECT_TRUE(obj != nullptr);
181 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
182 Return(AccessToken::PermissionState::PERMISSION_DENIED));
183 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
184 }
185
186 HWTEST_F(SecurityCollectorTest, CollectorStart02, TestSize.Level1)
187 {
188 SecurityCollectorSubscribeInfo info{};
189 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
190 EXPECT_TRUE(obj != nullptr);
191 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
192 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
193 EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce(Return(SecurityCollector::ErrorCode::FAILED));
194 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
195 }
196
197 HWTEST_F(SecurityCollectorTest, CollectorStart03, TestSize.Level1)
198 {
199 SecurityCollectorSubscribeInfo info{};
200 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
201 EXPECT_TRUE(obj != nullptr);
202 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
203 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anon2f99d3e50302(int64_t eventId, int32_t& collectorType) 204 EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
205 collectorType = 0;
206 return SecurityCollector::ErrorCode::SUCCESS;
207 });
208 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
209 }
210
211 HWTEST_F(SecurityCollectorTest, CollectorStart04, TestSize.Level1)
212 {
213 SecurityCollectorSubscribeInfo info{};
214 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
215 EXPECT_TRUE(obj != nullptr);
216 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
217 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anon2f99d3e50402(int64_t eventId, int32_t& collectorType) 218 EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
219 collectorType = 1;
220 return SecurityCollector::ErrorCode::SUCCESS;
221 });
222 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
223 Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
224 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
225 Return(SecurityCollector::ErrorCode::FAILED));
226 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
227 }
228
229 HWTEST_F(SecurityCollectorTest, CollectorStart05, TestSize.Level1)
230 {
231 SecurityCollectorSubscribeInfo info{};
232 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
233 EXPECT_TRUE(obj != nullptr);
234 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
235 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anon2f99d3e50502(int64_t eventId, int32_t& collectorType) 236 EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
237 collectorType = 1;
238 return SecurityCollector::ErrorCode::SUCCESS;
239 });
240 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
241 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
242 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anon2f99d3e50602(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 243 [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
244 nativeTokenInfoRes.processName = "processName";
245 return SecurityCollector::ErrorCode::SUCCESS;
246 });
247 EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StartCollector).WillOnce(Return(false));
248 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
249 }
250
251 HWTEST_F(SecurityCollectorTest, CollectorStart06, TestSize.Level1)
252 {
253 SecurityCollectorSubscribeInfo info{};
254 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
255 EXPECT_TRUE(obj != nullptr);
256 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
257 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
__anon2f99d3e50702(int64_t eventId, int32_t& collectorType) 258 EXPECT_CALL(DataCollection::GetInstance(), GetCollectorType).WillOnce([] (int64_t eventId, int32_t& collectorType) {
259 collectorType = 1;
260 return SecurityCollector::ErrorCode::SUCCESS;
261 });
262 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
263 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
264 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anon2f99d3e50802(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 265 [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
266 nativeTokenInfoRes.processName = "processName";
267 return SecurityCollector::ErrorCode::SUCCESS;
268 });
269 EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StartCollector).WillOnce(Return(true));
270 EXPECT_EQ(g_service.CollectorStart(info, obj), SecurityCollector::ErrorCode::SUCCESS);
271 }
272
273 HWTEST_F(SecurityCollectorTest, CollectorStop01, TestSize.Level1)
274 {
275 SecurityCollectorSubscribeInfo info{};
276 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
277 EXPECT_TRUE(obj != nullptr);
278 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
279 Return(AccessToken::PermissionState::PERMISSION_DENIED));
280 EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::NO_PERMISSION);
281 }
282
283 HWTEST_F(SecurityCollectorTest, CollectorStop02, TestSize.Level1)
284 {
285 SecurityCollectorSubscribeInfo info{};
286 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
287 EXPECT_TRUE(obj != nullptr);
288 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
289 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
290 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
291 Return(AccessToken::ATokenTypeEnum::TOKEN_HAP));
292 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetHapTokenInfo).WillOnce(
293 Return(SecurityCollector::ErrorCode::FAILED));
294 EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
295 }
296
297 HWTEST_F(SecurityCollectorTest, CollectorStop03, TestSize.Level1)
298 {
299 SecurityCollectorSubscribeInfo info{};
300 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
301 EXPECT_TRUE(obj != nullptr);
302 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
303 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
304 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
305 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
306 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anon2f99d3e50902(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 307 [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
308 nativeTokenInfoRes.processName = "processName";
309 return SecurityCollector::ErrorCode::SUCCESS;
310 });
311 EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StopCollector).WillOnce(Return(false));
312 EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::BAD_PARAM);
313 }
314
315 HWTEST_F(SecurityCollectorTest, CollectorStop04, TestSize.Level1)
316 {
317 SecurityCollectorSubscribeInfo info{};
318 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
319 EXPECT_TRUE(obj != nullptr);
320 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
321 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
322 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetTokenType).WillOnce(
323 Return(AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
324 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), GetNativeTokenInfo).WillOnce(
__anon2f99d3e50a02(AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) 325 [] (AccessToken::AccessTokenID tokenID, AccessToken::NativeTokenInfo& nativeTokenInfoRes) {
326 nativeTokenInfoRes.processName = "processName";
327 return SecurityCollector::ErrorCode::SUCCESS;
328 });
329 EXPECT_CALL(SecurityCollectorRunManager::GetInstance(), StopCollector).WillOnce(Return(true));
330 EXPECT_EQ(g_service.CollectorStop(info, obj), SecurityCollector::ErrorCode::SUCCESS);
331 }
332
333 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask01, TestSize.Level1)
334 {
335 Event event{};
336 sptr<MockRemoteObject> obj = nullptr;
337 g_service.ExecuteOnNotifyByTask(obj, event);
338 EXPECT_TRUE(obj == nullptr);
339 }
340
341 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask02, TestSize.Level1)
342 {
343 Event event{};
344 event.eventId = SecurityCollector::FILE_EVENTID;
345 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
346 EXPECT_TRUE(obj != nullptr);
347 EXPECT_CALL(*obj, SendRequest)
__anon2f99d3e50b02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 348 .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
349 g_service.OnRemoteRequest(code, data, reply, option);
350 return SecurityCollector::ErrorCode::SUCCESS;
351 });
352 g_service.ExecuteOnNotifyByTask(obj, event);
353 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
354 }
355
356 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask03, TestSize.Level1)
357 {
358 Event event{};
359 event.eventId = SecurityCollector::PROCESS_EVENTID;
360 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
361 EXPECT_TRUE(obj != nullptr);
362 EXPECT_CALL(*obj, SendRequest)
__anon2f99d3e50c02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 363 .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
364 g_service.OnRemoteRequest(code, data, reply, option);
365 return SecurityCollector::ErrorCode::SUCCESS;
366 });
367 g_service.ExecuteOnNotifyByTask(obj, event);
368 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
369 }
370
371 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask04, TestSize.Level1)
372 {
373 Event event{};
374 event.eventId = SecurityCollector::NETWORK_EVENTID;
375 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
376 EXPECT_TRUE(obj != nullptr);
377 EXPECT_CALL(*obj, SendRequest)
__anon2f99d3e50d02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 378 .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
379 g_service.OnRemoteRequest(code, data, reply, option);
380 return SecurityCollector::ErrorCode::SUCCESS;
381 });
382 g_service.ExecuteOnNotifyByTask(obj, event);
383 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
384 }
385
386 HWTEST_F(SecurityCollectorTest, ExecuteOnNotifyByTask05, TestSize.Level1)
387 {
388 Event event{};
389 sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject());
390 EXPECT_TRUE(obj != nullptr);
391 EXPECT_CALL(*obj, SendRequest)
__anon2f99d3e50e02(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 392 .WillOnce([](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
393 g_service.OnRemoteRequest(code, data, reply, option);
394 return SecurityCollector::ErrorCode::SUCCESS;
395 });
396 g_service.ExecuteOnNotifyByTask(obj, event);
397 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
398 }
399
400 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent01, TestSize.Level1)
401 {
402 std::vector<SecurityEventRuler> rulers{};
403 std::vector<SecurityEvent> events{};
404 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
405 Return(AccessToken::PermissionState::PERMISSION_DENIED));
406 EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::NO_PERMISSION);
407 }
408
409 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent02, TestSize.Level1)
410 {
411 std::vector<SecurityEventRuler> rulers{};
412 std::vector<SecurityEvent> events{};
413 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
414 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
415 EXPECT_CALL(DataCollection::GetInstance(), QuerySecurityEvent).WillOnce(
416 Return(OHOS::Security::SecurityGuard::FAILED));
417 EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::READ_ERR);
418 }
419
420 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent03, TestSize.Level1)
421 {
422 std::vector<SecurityEventRuler> rulers{};
423 std::vector<SecurityEvent> events{};
424 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
425 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
426 EXPECT_CALL(DataCollection::GetInstance(), QuerySecurityEvent).WillOnce(Return(
427 OHOS::Security::SecurityGuard::SUCCESS));
428 EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::SUCCESS);
429 }
430
431 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidInt, TestSize.Level1)
432 {
433 MessageParcel data;
434 MessageParcel reply;
435 MessageOption option;
436
437 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
438 data.WriteInt32(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE);
439 int32_t result =
440 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
441 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
442 }
443
444 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidCmd, TestSize.Level1)
445 {
446 MessageParcel data;
447 MessageParcel reply;
448 MessageOption option;
449
450 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
451 data.WriteInt32(100);
452 int32_t result = g_service.OnRemoteRequest(100, data, reply, option);
453 EXPECT_EQ(result, 305);
454 }
455
456 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidToken, TestSize.Level1)
457 {
458 MessageParcel data;
459 MessageParcel reply;
460 MessageOption option;
461
462 data.WriteInterfaceToken(u"InvalidToken");
463 int32_t result =
464 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
465 EXPECT_EQ(result, 305);
466 }
467
468 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd00, TestSize.Level1)
469 {
470 MessageParcel data;
471 MessageParcel reply;
472 MessageOption option;
473 SecurityCollectorSubscribeInfo subscribeInfo{};
474 sptr<MockRemoteObject> callback = nullptr;
475
476 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
477 int32_t result =
478 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
479 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
480 }
481
482 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd01, TestSize.Level1)
483 {
484 MessageParcel data;
485 MessageParcel reply;
486 MessageOption option;
487 SecurityCollectorSubscribeInfo subscribeInfo{};
488 sptr<MockRemoteObject> callback = nullptr;
489
490 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
491 data.WriteParcelable(&subscribeInfo);
492 data.WriteRemoteObject(callback);
493 int32_t result =
494 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
495 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
496 }
497
498 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd02, TestSize.Level1)
499 {
500 MessageParcel data;
501 MessageParcel reply;
502 MessageOption option;
503 SecurityCollectorSubscribeInfo subscribeInfo{};
504 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
505
506 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
507 data.WriteParcelable(&subscribeInfo);
508 data.WriteRemoteObject(callback);
509 int32_t result =
510 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
511 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
512 }
513
514 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd03, TestSize.Level1)
515 {
516 MessageParcel data;
517 MessageParcel reply;
518 MessageOption option;
519
520 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
521 int32_t result =
522 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
523 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
524 }
525
526 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd04, TestSize.Level1)
527 {
528 MessageParcel data;
529 MessageParcel reply;
530 MessageOption option;
531 sptr<MockRemoteObject> callback = nullptr;
532
533 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
534 data.WriteRemoteObject(callback);
535 int32_t result =
536 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
537 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
538 }
539
540 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd05, TestSize.Level1)
541 {
542 MessageParcel data;
543 MessageParcel reply;
544 MessageOption option;
545 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
546
547 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
548 data.WriteRemoteObject(callback);
549 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
550 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
551 int32_t result =
552 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
553 EXPECT_EQ(result, SecurityCollector::ErrorCode::FAILED);
554 }
555
556 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd06, TestSize.Level1)
557 {
558 MessageParcel data;
559 MessageParcel reply;
560 MessageOption option;
561 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
562
563 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
564 int32_t result =
565 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
566 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
567 }
568
569 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd07, TestSize.Level1)
570 {
571 MessageParcel data;
572 MessageParcel reply;
573 MessageOption option;
574 SecurityCollectorSubscribeInfo subscribeInfo{};
575 sptr<MockRemoteObject> callback = nullptr;
576
577 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
578 data.WriteParcelable(&subscribeInfo);
579 data.WriteRemoteObject(callback);
580 int32_t result =
581 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
582 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
583 }
584
585 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd08, TestSize.Level1)
586 {
587 MessageParcel data;
588 MessageParcel reply;
589 MessageOption option;
590 SecurityCollectorSubscribeInfo subscribeInfo{};
591 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
592
593 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
594 data.WriteParcelable(&subscribeInfo);
595 data.WriteRemoteObject(callback);
596 int32_t result =
597 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
598 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
599 }
600
601 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd09, TestSize.Level1)
602 {
603 MessageParcel data;
604 MessageParcel reply;
605 MessageOption option;
606
607 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
608 int32_t result =
609 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
610 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
611 }
612
613 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd10, TestSize.Level1)
614 {
615 MessageParcel data;
616 MessageParcel reply;
617 MessageOption option;
618 SecurityCollectorSubscribeInfo subscribeInfo{};
619 sptr<MockRemoteObject> callback = nullptr;
620
621 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
622 data.WriteParcelable(&subscribeInfo);
623 data.WriteRemoteObject(callback);
624 int32_t result =
625 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
626 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
627 }
628
629 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd11, TestSize.Level1)
630 {
631 MessageParcel data;
632 MessageParcel reply;
633 MessageOption option;
634 SecurityCollectorSubscribeInfo subscribeInfo{};
635 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
636
637 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
638 data.WriteParcelable(&subscribeInfo);
639 data.WriteRemoteObject(callback);
640 int32_t result =
641 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
642 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
643 }
644
645 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd12, TestSize.Level1)
646 {
647 MessageParcel data;
648 MessageParcel reply;
649 MessageOption option;
650 int fd = 1;
651 std::vector<std::u16string> args;
652 g_service.Dump(fd, args);
653 int32_t systemAbilityId = 0;
654 const std::string& deviceId = "test";
655 g_service.OnStop();
656 g_service.OnAddSystemAbility(systemAbilityId, deviceId);
657 g_service.OnRemoveSystemAbility(systemAbilityId, deviceId);
658
659 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
660 int32_t result =
661 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
662 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
663 }
664
665 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd13, TestSize.Level1)
666 {
667 MessageParcel data;
668 MessageParcel reply;
669 MessageOption option;
670 SecurityCollectorSubscribeInfo subscribeInfo{};
671
672 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
673 data.WriteInt32(SecurityCollector::MAX_QUERY_EVENT_SIZE + 1);
674 int32_t result =
675 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
676 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
677 }
678
679 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd14, TestSize.Level1)
680 {
681 wptr<SecurityCollectorManagerService> service1
682 = new SecurityCollectorManagerService(1, false);
683 SecurityCollectorManagerService::SubscriberDeathRecipient testRecipient(service1);
684 wptr<MockRemoteObject> remote1 = new MockRemoteObject();
685 testRecipient.OnRemoteDied(remote1);
686 testRecipient.OnRemoteDied(nullptr);
687
688 MessageParcel data;
689 MessageParcel reply;
690 MessageOption option;
691 SecurityCollector::SecurityEventRuler ruler{};
692
693 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
694 data.WriteInt32(1);
695 data.WriteParcelable(&ruler);
696 int32_t result =
697 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
698 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
699 }
700
701 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd15, TestSize.Level1)
702 {
703 MessageParcel data;
704 MessageParcel reply;
705 MessageOption option;
706 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
707 int32_t result =
708 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_MUTE, data, reply, option);
709 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
710 }
711
712 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd16, TestSize.Level1)
713 {
714 MessageParcel data;
715 MessageParcel reply;
716 MessageOption option;
717 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
718 Return(AccessToken::PermissionState::PERMISSION_DENIED));
719 SecurityCollectorEventMuteFilter fil {};
720 fil.eventId = 1;
721 fil.isSetMute = true;
722 SecurityCollectorEventFilter filter(fil);
723 std::string flag = "test";
724 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
725 data.WriteParcelable(&filter);
726 data.WriteString(flag);
727 int32_t result =
728 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_MUTE, data, reply, option);
729 EXPECT_EQ(result, SecurityCollector::ErrorCode::NO_PERMISSION);
730 }
731
732 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd17, TestSize.Level1)
733 {
734 MessageParcel data;
735 MessageParcel reply;
736 MessageOption option;
737 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
738 int32_t result =
739 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_UNMUTE, data, reply, option);
740 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
741 }
742
743 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd18, TestSize.Level1)
744 {
745 MessageParcel data;
746 MessageParcel reply;
747 MessageOption option;
748 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
749 Return(AccessToken::PermissionState::PERMISSION_DENIED));
750 SecurityCollectorEventMuteFilter fil {};
751 fil.eventId = 1;
752 fil.isSetMute = true;
753 SecurityCollectorEventFilter filter(fil);
754 std::string flag = "test";
755 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
756 data.WriteParcelable(&filter);
757 data.WriteString(flag);
758 int32_t result =
759 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_UNMUTE, data, reply, option);
760 EXPECT_EQ(result, SecurityCollector::ErrorCode::NO_PERMISSION);
761 }
762
763 HWTEST_F(SecurityCollectorTest, TestLoaderLib002, TestSize.Level1)
764 {
765 LibLoader loader("");
766 EXPECT_EQ(loader.LoadLib(), RET_DLOPEN_LIB_FAIL);
767 EXPECT_EQ(loader.CallGetCollector(), nullptr);
768 LibLoader loader1("/system/etc/security_audit.cfg");
769 EXPECT_EQ(loader1.LoadLib(), RET_DLOPEN_LIB_FAIL);
770 }
771
772 HWTEST_F(SecurityCollectorTest, RemoveFilter, TestSize.Level1)
773 {
774 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
775 Return(AccessToken::PermissionState::PERMISSION_DENIED)).WillOnce(
776 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
777 SecurityCollectorEventMuteFilter fil {};
778 SecurityCollectorEventFilter filter(fil);
779 int32_t ret = g_service.RemoveFilter(filter);
780 EXPECT_EQ(ret, SecurityCollector::ErrorCode::NO_PERMISSION);
781 ret = g_service.RemoveFilter(filter);
782 EXPECT_EQ(ret, SecurityCollector::ErrorCode::SUCCESS);
783 }
784
785 HWTEST_F(SecurityCollectorTest, AddFilter, TestSize.Level1)
786 {
787 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
788 Return(AccessToken::PermissionState::PERMISSION_DENIED)).WillOnce(
789 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
790 SecurityCollectorEventMuteFilter fil {};
791 SecurityCollectorEventFilter filter(fil);
792 int32_t ret = g_service.AddFilter(filter);
793 EXPECT_EQ(ret, SecurityCollector::ErrorCode::NO_PERMISSION);
794 ret = g_service.AddFilter(filter);
795 EXPECT_EQ(ret, SecurityCollector::ErrorCode::SUCCESS);
796 }
797 }