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(
__anon4dffffc30102(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(
__anon4dffffc30202(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));
__anon4dffffc30302(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));
__anon4dffffc30402(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));
__anon4dffffc30502(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(
__anon4dffffc30602(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));
__anon4dffffc30702(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(
__anon4dffffc30802(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(
__anon4dffffc30902(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(
__anon4dffffc30a02(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)
__anon4dffffc30b02(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)
__anon4dffffc30c02(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)
__anon4dffffc30d02(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)
__anon4dffffc30e02(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(Return(false));
416 EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::READ_ERR);
417 }
418
419 HWTEST_F(SecurityCollectorTest, QuerySecurityEvent03, TestSize.Level1)
420 {
421 std::vector<SecurityEventRuler> rulers{};
422 std::vector<SecurityEvent> events{};
423 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
424 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
425 EXPECT_CALL(DataCollection::GetInstance(), QuerySecurityEvent).WillOnce(Return(true));
426 EXPECT_EQ(g_service.QuerySecurityEvent(rulers, events), SecurityCollector::ErrorCode::SUCCESS);
427 }
428
429 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidInt, TestSize.Level1)
430 {
431 MessageParcel data;
432 MessageParcel reply;
433 MessageOption option;
434
435 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
436 data.WriteInt32(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE);
437 int32_t result =
438 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
439 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
440 }
441
442 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidCmd, TestSize.Level1)
443 {
444 MessageParcel data;
445 MessageParcel reply;
446 MessageOption option;
447
448 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
449 data.WriteInt32(100);
450 int32_t result = g_service.OnRemoteRequest(100, data, reply, option);
451 EXPECT_EQ(result, 305);
452 }
453
454 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithInvalidToken, TestSize.Level1)
455 {
456 MessageParcel data;
457 MessageParcel reply;
458 MessageOption option;
459
460 data.WriteInterfaceToken(u"InvalidToken");
461 int32_t result =
462 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
463 EXPECT_EQ(result, 305);
464 }
465
466 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd00, TestSize.Level1)
467 {
468 MessageParcel data;
469 MessageParcel reply;
470 MessageOption option;
471 SecurityCollectorSubscribeInfo subscribeInfo{};
472 sptr<MockRemoteObject> callback = nullptr;
473
474 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
475 int32_t result =
476 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
477 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
478 }
479
480 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd01, TestSize.Level1)
481 {
482 MessageParcel data;
483 MessageParcel reply;
484 MessageOption option;
485 SecurityCollectorSubscribeInfo subscribeInfo{};
486 sptr<MockRemoteObject> callback = nullptr;
487
488 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
489 data.WriteParcelable(&subscribeInfo);
490 data.WriteRemoteObject(callback);
491 int32_t result =
492 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
493 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
494 }
495
496 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd02, TestSize.Level1)
497 {
498 MessageParcel data;
499 MessageParcel reply;
500 MessageOption option;
501 SecurityCollectorSubscribeInfo subscribeInfo{};
502 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
503
504 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
505 data.WriteParcelable(&subscribeInfo);
506 data.WriteRemoteObject(callback);
507 int32_t result =
508 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_SUBCRIBE, data, reply, option);
509 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
510 }
511
512 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd03, TestSize.Level1)
513 {
514 MessageParcel data;
515 MessageParcel reply;
516 MessageOption option;
517
518 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
519 int32_t result =
520 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
521 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
522 }
523
524 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd04, TestSize.Level1)
525 {
526 MessageParcel data;
527 MessageParcel reply;
528 MessageOption option;
529 sptr<MockRemoteObject> callback = nullptr;
530
531 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
532 data.WriteRemoteObject(callback);
533 int32_t result =
534 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
535 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
536 }
537
538 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd05, TestSize.Level1)
539 {
540 MessageParcel data;
541 MessageParcel reply;
542 MessageOption option;
543 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
544
545 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
546 data.WriteRemoteObject(callback);
547 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
548 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
549 int32_t result =
550 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
551 EXPECT_EQ(result, SecurityCollector::ErrorCode::FAILED);
552 }
553
554 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd06, TestSize.Level1)
555 {
556 MessageParcel data;
557 MessageParcel reply;
558 MessageOption option;
559 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
560
561 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
562 int32_t result =
563 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
564 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
565 }
566
567 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd07, TestSize.Level1)
568 {
569 MessageParcel data;
570 MessageParcel reply;
571 MessageOption option;
572 SecurityCollectorSubscribeInfo subscribeInfo{};
573 sptr<MockRemoteObject> callback = nullptr;
574
575 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
576 data.WriteParcelable(&subscribeInfo);
577 data.WriteRemoteObject(callback);
578 int32_t result =
579 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
580 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
581 }
582
583 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd08, TestSize.Level1)
584 {
585 MessageParcel data;
586 MessageParcel reply;
587 MessageOption option;
588 SecurityCollectorSubscribeInfo subscribeInfo{};
589 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
590
591 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
592 data.WriteParcelable(&subscribeInfo);
593 data.WriteRemoteObject(callback);
594 int32_t result =
595 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_START, data, reply, option);
596 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
597 }
598
599 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd09, TestSize.Level1)
600 {
601 MessageParcel data;
602 MessageParcel reply;
603 MessageOption option;
604
605 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
606 int32_t result =
607 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
608 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
609 }
610
611 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd10, TestSize.Level1)
612 {
613 MessageParcel data;
614 MessageParcel reply;
615 MessageOption option;
616 SecurityCollectorSubscribeInfo subscribeInfo{};
617 sptr<MockRemoteObject> callback = nullptr;
618
619 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
620 data.WriteParcelable(&subscribeInfo);
621 data.WriteRemoteObject(callback);
622 int32_t result =
623 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
624 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
625 }
626
627 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd11, TestSize.Level1)
628 {
629 MessageParcel data;
630 MessageParcel reply;
631 MessageOption option;
632 SecurityCollectorSubscribeInfo subscribeInfo{};
633 sptr<MockRemoteObject> callback(new (std::nothrow) MockRemoteObject());
634
635 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
636 data.WriteParcelable(&subscribeInfo);
637 data.WriteRemoteObject(callback);
638 int32_t result =
639 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_COLLECTOR_STOP, data, reply, option);
640 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
641 }
642
643 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd12, TestSize.Level1)
644 {
645 MessageParcel data;
646 MessageParcel reply;
647 MessageOption option;
648 int fd = 1;
649 std::vector<std::u16string> args;
650 g_service.Dump(fd, args);
651 int32_t systemAbilityId = 0;
652 const std::string& deviceId = "test";
653 g_service.OnStop();
654 g_service.OnAddSystemAbility(systemAbilityId, deviceId);
655 g_service.OnRemoveSystemAbility(systemAbilityId, deviceId);
656
657 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
658 int32_t result =
659 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
660 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
661 }
662
663 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd13, TestSize.Level1)
664 {
665 MessageParcel data;
666 MessageParcel reply;
667 MessageOption option;
668 SecurityCollectorSubscribeInfo subscribeInfo{};
669
670 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
671 data.WriteInt32(SecurityCollector::MAX_QUERY_EVENT_SIZE + 1);
672 int32_t result =
673 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
674 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
675 }
676
677 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd14, TestSize.Level1)
678 {
679 wptr<SecurityCollectorManagerService> service1
680 = new SecurityCollectorManagerService(1, false);
681 SecurityCollectorManagerService::SubscriberDeathRecipient testRecipient(service1);
682 wptr<MockRemoteObject> remote1 = new MockRemoteObject();
683 testRecipient.OnRemoteDied(remote1);
684 testRecipient.OnRemoteDied(nullptr);
685
686 MessageParcel data;
687 MessageParcel reply;
688 MessageOption option;
689 SecurityCollector::SecurityEventRuler ruler{};
690
691 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
692 data.WriteInt32(1);
693 data.WriteParcelable(&ruler);
694 int32_t result =
695 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_QUERY, data, reply, option);
696 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
697 }
698
699 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd15, TestSize.Level1)
700 {
701 MessageParcel data;
702 MessageParcel reply;
703 MessageOption option;
704 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
705 int32_t result =
706 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_MUTE, data, reply, option);
707 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
708 }
709
710 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd16, TestSize.Level1)
711 {
712 MessageParcel data;
713 MessageParcel reply;
714 MessageOption option;
715 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
716 Return(AccessToken::PermissionState::PERMISSION_DENIED));
717 SecurityCollectorEventMuteFilter fil {};
718 fil.eventId = 1;
719 fil.isSetMute = true;
720 SecurityCollectorEventFilter filter(fil);
721 std::string flag = "test";
722 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
723 data.WriteParcelable(&filter);
724 data.WriteString(flag);
725 int32_t result =
726 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_MUTE, data, reply, option);
727 EXPECT_EQ(result, SecurityCollector::ErrorCode::NO_PERMISSION);
728 }
729
730 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd17, TestSize.Level1)
731 {
732 MessageParcel data;
733 MessageParcel reply;
734 MessageOption option;
735 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
736 int32_t result =
737 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_UNMUTE, data, reply, option);
738 EXPECT_EQ(result, SecurityCollector::ErrorCode::BAD_PARAM);
739 }
740
741 HWTEST_F(SecurityCollectorTest, TestOnRemoteRequestWithCmd18, TestSize.Level1)
742 {
743 MessageParcel data;
744 MessageParcel reply;
745 MessageOption option;
746 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
747 Return(AccessToken::PermissionState::PERMISSION_DENIED));
748 SecurityCollectorEventMuteFilter fil {};
749 fil.eventId = 1;
750 fil.isSetMute = true;
751 SecurityCollectorEventFilter filter(fil);
752 std::string flag = "test";
753 data.WriteInterfaceToken(ISecurityCollectorManager::GetDescriptor());
754 data.WriteParcelable(&filter);
755 data.WriteString(flag);
756 int32_t result =
757 g_service.OnRemoteRequest(SecurityCollectorManagerService::CMD_SECURITY_EVENT_UNMUTE, data, reply, option);
758 EXPECT_EQ(result, SecurityCollector::ErrorCode::NO_PERMISSION);
759 }
760
761 HWTEST_F(SecurityCollectorTest, TestLoaderLib002, TestSize.Level1)
762 {
763 LibLoader loader("");
764 EXPECT_EQ(loader.LoadLib(), RET_DLOPEN_LIB_FAIL);
765 EXPECT_EQ(loader.CallGetCollector(), nullptr);
766 LibLoader loader1("/system/etc/security_audit.cfg");
767 EXPECT_EQ(loader1.LoadLib(), RET_DLOPEN_LIB_FAIL);
768 }
769
770 HWTEST_F(SecurityCollectorTest, Unmute, TestSize.Level1)
771 {
772 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
773 Return(AccessToken::PermissionState::PERMISSION_DENIED)).WillOnce(
774 Return(AccessToken::PermissionState::PERMISSION_GRANTED)).WillOnce(
775 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
776 EXPECT_CALL(DataCollection::GetInstance(), Unmute).WillOnce(Return(false)).WillOnce(Return(true));
777 SecurityCollectorEventMuteFilter fil {};
778 SecurityCollectorEventFilter filter(fil);
779 int32_t ret = g_service.Unmute(filter, "111");
780 EXPECT_EQ(ret, SecurityCollector::ErrorCode::NO_PERMISSION);
781 ret = g_service.Unmute(filter, "111");
782 EXPECT_EQ(ret, SecurityCollector::ErrorCode::FAILED);
783 ret = g_service.Unmute(filter, "111");
784 EXPECT_EQ(ret, SecurityCollector::ErrorCode::SUCCESS);
785 }
786
787 HWTEST_F(SecurityCollectorTest, Mute, TestSize.Level1)
788 {
789 EXPECT_CALL(*(AccessToken::AccessTokenKit::GetInterface()), VerifyAccessToken).WillOnce(
790 Return(AccessToken::PermissionState::PERMISSION_DENIED)).WillOnce(
791 Return(AccessToken::PermissionState::PERMISSION_GRANTED)).WillOnce(
792 Return(AccessToken::PermissionState::PERMISSION_GRANTED));
793 EXPECT_CALL(DataCollection::GetInstance(), Mute).WillOnce(Return(false)).WillOnce(Return(true));
794 SecurityCollectorEventMuteFilter fil {};
795 SecurityCollectorEventFilter filter(fil);
796 int32_t ret = g_service.Mute(filter, "111");
797 EXPECT_EQ(ret, SecurityCollector::ErrorCode::NO_PERMISSION);
798 ret = g_service.Mute(filter, "111");
799 EXPECT_EQ(ret, SecurityCollector::ErrorCode::FAILED);
800 ret = g_service.Mute(filter, "111");
801 EXPECT_EQ(ret, SecurityCollector::ErrorCode::SUCCESS);
802 }
803 }