1 /*
2 * Copyright (c) 2022 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_guard_data_collect_test.h"
17 #include <fstream>
18 #include "directory_ex.h"
19 #include "file_ex.h"
20 #include "gmock/gmock.h"
21
22 #include "security_guard_define.h"
23 #include "security_guard_log.h"
24 #include "security_guard_utils.h"
25 #include "store_define.h"
26 #define private public
27 #define protected public
28 #include "config_data_manager.h"
29 #include "database.h"
30 #include "database_manager.h"
31 #include "os_account_manager.h"
32 #include "preferences_helper.h"
33 #include "risk_event_rdb_helper.h"
34 #undef private
35 #undef protected
36
37 using namespace testing;
38 using namespace testing::ext;
39 using namespace OHOS::Security::SecurityGuard;
40 using namespace OHOS::Security::SecurityGuardTest;
41
42 namespace OHOS {
43 std::mutex AccountSA::OsAccountManager::mutex_ {};
44 std::mutex NativePreferences::PreferencesHelper::mutex_ {};
45 }
46
47 namespace OHOS::Security::SecurityGuardTest {
48 namespace {
49 constexpr int SUCCESS = 0;
50 }
51
SetUpTestCase()52 void SecurityGuardDataCollectTest::SetUpTestCase()
53 {
54 }
55
TearDownTestCase()56 void SecurityGuardDataCollectTest::TearDownTestCase()
57 {
58 }
59
SetUp()60 void SecurityGuardDataCollectTest::SetUp()
61 {
62 }
63
TearDown()64 void SecurityGuardDataCollectTest::TearDown()
65 {
66 }
67
68 HWTEST_F(SecurityGuardDataCollectTest, InitCleanup, TestSize.Level1)
69 {
70 RiskEventRdbHelper helper;
71 int32_t ret = helper.Init();
72 EXPECT_EQ(ret, SUCCESS);
73 DatabaseHelper helper1("");
74 EXPECT_EQ(helper1.Init(), SUCCESS);
75 }
76
77 HWTEST_F(SecurityGuardDataCollectTest, InsertSpecCharContent, TestSize.Level1)
78 {
79 RiskEventRdbHelper helper;
80 EXPECT_EQ(helper.Init(), SUCCESS);
81 SecEvent event{};
82 event.content = "invalid";
83 EXPECT_NE(helper.InsertEvent(event), BAD_PARAM);
84 }
85
86 HWTEST_F(SecurityGuardDataCollectTest, FullFieldQuery, TestSize.Level1)
87 {
88 RiskEventRdbHelper helper;
89 EXPECT_EQ(helper.Init(), SUCCESS);
90 std::vector<SecEvent> results;
91 helper.QueryAllEvent(results);
92 EXPECT_FALSE(results.empty());
93 }
94
95 HWTEST_F(SecurityGuardDataCollectTest, TestQueryRecentEventByEventId, TestSize.Level1)
96 {
97 RiskEventRdbHelper helper;
98 EXPECT_EQ(helper.Init(), SUCCESS);
99 SecEvent event{};
100 int64_t eventId = 0;
101 EXPECT_NE(helper.QueryRecentEventByEventId(eventId, event), BAD_PARAM);
102 }
103
104 HWTEST_F(SecurityGuardDataCollectTest, TestQueryRecentEventByEventIds, TestSize.Level1)
105 {
106 RiskEventRdbHelper helper;
107 EXPECT_EQ(helper.Init(), SUCCESS);
108 std::vector<SecEvent> results;
109 std::vector<int64_t> eventIds;
110 eventIds.push_back(1);
111 eventIds.push_back(0);
112 EXPECT_EQ(helper.QueryRecentEventByEventId(eventIds, results), SUCCESS);
113 }
114
115 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByEventId, TestSize.Level1)
116 {
117 RiskEventRdbHelper helper;
118 EXPECT_EQ(helper.Init(), SUCCESS);
119 std::vector<SecEvent> results;
120 int64_t eventId = 0;
121 EXPECT_EQ(helper.QueryEventByEventId(eventId, results), SUCCESS);
122 }
123
124 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByEventIdS, TestSize.Level1)
125 {
126 RiskEventRdbHelper helper;
127 EXPECT_EQ(helper.Init(), SUCCESS);
128 std::vector<SecEvent> results;
129 std::vector<int64_t> eventIds;
130 eventIds.push_back(1);
131 eventIds.push_back(0);
132 EXPECT_EQ(helper.QueryEventByEventId(eventIds, results), SUCCESS);
133 }
134
135 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByDate, TestSize.Level1)
136 {
137 RiskEventRdbHelper helper;
138 EXPECT_EQ(helper.Init(), SUCCESS);
139 std::vector<SecEvent> results;
140 std::vector<int64_t> eventIds;
141 std::string date{"111"};
142 EXPECT_NE(helper.QueryEventByEventIdAndDate(eventIds, results, date, date), SUCCESS);
143 }
144
145 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByType, TestSize.Level1)
146 {
147 RiskEventRdbHelper helper;
148 EXPECT_EQ(helper.Init(), SUCCESS);
149 std::vector<SecEvent> results;
150 EXPECT_EQ(helper.QueryEventByEventType(0, results), SUCCESS);
151 }
152
153 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByLevel, TestSize.Level1)
154 {
155 RiskEventRdbHelper helper;
156 EXPECT_EQ(helper.Init(), SUCCESS);
157 std::vector<SecEvent> results;
158 EXPECT_EQ(helper.QueryEventByLevel(0, results), SUCCESS);
159 }
160
161 HWTEST_F(SecurityGuardDataCollectTest, TestQueryByOwner, TestSize.Level1)
162 {
163 RiskEventRdbHelper helper;
164 EXPECT_EQ(helper.Init(), SUCCESS);
165 std::vector<SecEvent> results;
166 std::string owner;
167 EXPECT_EQ(helper.QueryEventByOwner(owner, results), SUCCESS);
168 }
169
170 HWTEST_F(SecurityGuardDataCollectTest, TestCountAllEvent, TestSize.Level1)
171 {
172 RiskEventRdbHelper helper;
173 EXPECT_EQ(helper.Init(), SUCCESS);
174 EXPECT_NE(helper.CountAllEvent(), 0);
175 }
176
177 HWTEST_F(SecurityGuardDataCollectTest, TestCountEventByID, TestSize.Level1)
178 {
179 RiskEventRdbHelper helper;
180 EXPECT_EQ(helper.Init(), SUCCESS);
181 EXPECT_NE(helper.CountEventByEventId(0), BAD_PARAM);
182 }
183
184 HWTEST_F(SecurityGuardDataCollectTest, TestDeleteOldEvent, TestSize.Level1)
185 {
186 RiskEventRdbHelper helper;
187 EXPECT_EQ(helper.Init(), SUCCESS);
188 EXPECT_NE(helper.DeleteOldEventByEventId(0, 0), SUCCESS);
189 EXPECT_EQ(helper.DeleteOldEventByEventId(0, 1), SUCCESS);
190 }
191
192 HWTEST_F(SecurityGuardDataCollectTest, TestDeleteAllEvent, TestSize.Level1)
193 {
194 RiskEventRdbHelper helper;
195 EXPECT_EQ(helper.Init(), SUCCESS);
196 EXPECT_NE(helper.DeleteAllEventByEventId(-1), SUCCESS);
197 EXPECT_NE(helper.DeleteAllEventByEventId(0), BAD_PARAM);
198 }
199
200 HWTEST_F(SecurityGuardDataCollectTest, TestFlushAllEvent, TestSize.Level1)
201 {
202 RiskEventRdbHelper helper;
203 EXPECT_EQ(helper.Init(), SUCCESS);
204 EXPECT_EQ(helper.FlushAllEvent(), SUCCESS);
205 }
206
207 HWTEST_F(SecurityGuardDataCollectTest, TestQueryEventBase, TestSize.Level1)
208 {
209 RiskEventRdbHelper helper;
210 EXPECT_EQ(helper.Init(), SUCCESS);
211 GenericValues conditions;
212 std::vector<SecEvent> events;
213 EXPECT_EQ(helper.QueryEventBase(conditions, events), SUCCESS);
214 }
215
216 HWTEST_F(SecurityGuardDataCollectTest, TestCreateTable, TestSize.Level1)
217 {
218 RiskEventRdbHelper helper;
219 EXPECT_TRUE(!helper.CreateTable().empty());
220 }
221
222 HWTEST_F(SecurityGuardDataCollectTest, TestSetValueBucket, TestSize.Level1)
223 {
224 RiskEventRdbHelper helper;
225 EXPECT_EQ(helper.Init(), SUCCESS);
226 SecEvent event{};
227 event.content = "11111";
228 GenericValues value;
229 helper.SetValuesBucket(event, value);
230 }
231
232 HWTEST_F(SecurityGuardDataCollectTest, TestJoin, TestSize.Level1)
233 {
234 RiskEventRdbHelper helper;
235 std::vector<std::string> vec;
236 EXPECT_TRUE(helper.Join(vec, "").empty());
237
238 vec.push_back("1111,1111,1111,1111");
239 EXPECT_FALSE(helper.Join(vec, ",").empty());
240
241 std::vector<int64_t> nums;
242 EXPECT_TRUE(helper.Join(nums, "").empty());
243
244 nums.push_back(11111);
245 nums.push_back(22222);
246 EXPECT_FALSE(helper.Join(nums, ",").empty());
247 EXPECT_FALSE(helper.FilterSpecialChars("11111").empty());
248 }
249
250
251 HWTEST_F(SecurityGuardDataCollectTest, StrToULL001, TestSize.Level1)
252 {
253 std::string test = "abc";
254 unsigned long long value = 0;
255 EXPECT_FALSE(SecurityGuardUtils::StrToULL(test, value));
256 test = "1844674407370955161511111";
257 EXPECT_FALSE(SecurityGuardUtils::StrToULL(test, value));
258 test = "abc111";
259 EXPECT_FALSE(SecurityGuardUtils::StrToULL(test, value));
260 test = "111aaa";
261 EXPECT_FALSE(SecurityGuardUtils::StrToULL(test, value));
262 test = "aaa";
263 EXPECT_FALSE(SecurityGuardUtils::StrToULL(test, value));
264 test = "111";
265 EXPECT_TRUE(SecurityGuardUtils::StrToULL(test, value));
266 }
267
268 HWTEST_F(SecurityGuardDataCollectTest, StrToLL001, TestSize.Level1)
269 {
270 std::string test = "abc";
271 long long value = 0;
272 int32_t dec = 10;
273 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, dec));
274 test = "1844674407370955161511111";
275 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, dec));
276 test = "abc111";
277 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, dec));
278 test = "111aaa";
279 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, dec));
280 test = "aaa";
281 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, dec));
282 test = "111";
283 EXPECT_TRUE(SecurityGuardUtils::StrToLL(test, value, dec));
284 }
285
286 HWTEST_F(SecurityGuardDataCollectTest, StrToLL002, TestSize.Level1)
287 {
288 std::string test = "zzz";
289 long long value = 0;
290 int32_t hec = 16;
291 EXPECT_FALSE(SecurityGuardUtils::StrToLL(test, value, hec));
292 }
293
294 HWTEST_F(SecurityGuardDataCollectTest, StrToU32001, TestSize.Level1)
295 {
296 std::string test = "123";
297 uint32_t value = 0;
298 EXPECT_TRUE(SecurityGuardUtils::StrToU32(test, value));
299 test = "1844674407370955161511111";
300 EXPECT_FALSE(SecurityGuardUtils::StrToU32(test, value));
301 test = "111bac";
302 EXPECT_FALSE(SecurityGuardUtils::StrToU32(test, value));
303 }
304
305 HWTEST_F(SecurityGuardDataCollectTest, StrToI64001, TestSize.Level1)
306 {
307 std::string test = "123";
308 int64_t value = 0;
309 EXPECT_TRUE(SecurityGuardUtils::StrToI64(test, value));
310 test = "1844674407370955161511111";
311 EXPECT_FALSE(SecurityGuardUtils::StrToI64(test, value));
312 test = "-1844674407370955161511111";
313 EXPECT_FALSE(SecurityGuardUtils::StrToI64(test, value));
314 test = "111bac";
315 EXPECT_FALSE(SecurityGuardUtils::StrToI64(test, value));
316 }
317
318 HWTEST_F(SecurityGuardDataCollectTest, StrToI64Hex001, TestSize.Level1)
319 {
320 std::string test = "abc";
321 int64_t value = 0;
322 EXPECT_FALSE(SecurityGuardUtils::StrToI64Hex(test, value));
323 test = "1844674407370955161511111";
324 EXPECT_FALSE(SecurityGuardUtils::StrToI64Hex(test, value));
325 test = "-1844674407370955161511111";
326 EXPECT_FALSE(SecurityGuardUtils::StrToI64Hex(test, value));
327 test = "111bac";
328 EXPECT_FALSE(SecurityGuardUtils::StrToI64Hex(test, value));
329 test = "0x111";
330 EXPECT_TRUE(SecurityGuardUtils::StrToI64Hex(test, value));
331 }
332
333 HWTEST_F(SecurityGuardDataCollectTest, TestCopyFile001, TestSize.Level1)
334 {
335 const std::string CONFIG_CACHE_FILE = "${sg_root_dir}/oem_property/hos/security_guard_event.json";
336 const std::string CONFIG_UPTATE_FILE = "/data/service/el1/public/security_guard/security_guard_event.json";
337 std::ifstream src(CONFIG_CACHE_FILE, std::ios::binary);
338 EXPECT_FALSE(SecurityGuardUtils::CopyFile(CONFIG_CACHE_FILE, CONFIG_UPTATE_FILE));
339 }
340
341 HWTEST_F(SecurityGuardDataCollectTest, TestGetDate001, TestSize.Level1)
342 {
343 std::string date = SecurityGuardUtils::GetDate();
344 EXPECT_TRUE(!date.empty());
345 }
346
347 }