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 "inner_sdk_fuzzer.h"
17
18 #include <string>
19 #include <fuzzer/FuzzedDataProvider.h>
20 #include "securec.h"
21
22 #define private public
23 #define protected public
24 #include "data_collect_manager.h"
25 #include "acquire_data_manager_callback_service.h"
26 #include "acquire_data_manager_callback_stub.h"
27 #include "data_collect_manager_callback_service.h"
28 #include "data_collect_manager_callback_stub.h"
29 #include "data_collect_manager_proxy.h"
30 #ifndef SECURITY_GUARD_TRIM_MODEL_ANALYSIS
31 #include "risk_analysis_manager_callback_service.h"
32 #include "risk_analysis_manager_callback_stub.h"
33 #include "risk_analysis_manager_callback.h"
34 #include "risk_analysis_manager_proxy.h"
35 #endif
36 #include "collector_manager.h"
37 #include "security_collector_manager_callback_stub.h"
38 #include "security_collector_manager_proxy.h"
39 #include "security_collector_subscribe_info.h"
40 #include "security_event.h"
41 #include "security_event_ruler.h"
42 #include "security_event_query_callback_service.h"
43 #undef private
44 #undef protected
45
46 using namespace OHOS::Security::SecurityGuard;
47 using namespace OHOS::Security::SecurityCollector;
48 namespace {
49 constexpr int MAX_STRING_SIZE = 1024;
50 }
51 namespace OHOS {
52 class MockCollectorSubscriber : public ICollectorSubscriber {
53 public:
MockCollectorSubscriber(const Event & event)54 explicit MockCollectorSubscriber(const Event &event) : ICollectorSubscriber(event) {};
OnNotify(const Event & event)55 int32_t OnNotify(const Event &event) override { return 0; };
56 };
57
58 class MockRemoteObject final : public IRemoteObject {
59 public:
MockRemoteObject()60 MockRemoteObject() : IRemoteObject(u"")
61 {
62 }
GetObjectRefCount()63 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)64 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)65 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)66 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)67 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
68 };
69
70 class MockAcquireDataManagerCallbackStub : public AcquireDataManagerCallbackStub {
71 public:
72 explicit MockAcquireDataManagerCallbackStub() = default;
73 ~MockAcquireDataManagerCallbackStub() override = default;
OnNotify(const std::vector<Security::SecurityCollector::Event> & events)74 int32_t OnNotify(const std::vector<Security::SecurityCollector::Event> &events) override { return 0; };
75 };
76
77 #ifndef SECURITY_GUARD_TRIM_MODEL_ANALYSIS
78 class MockRiskAnalysisManagerCallbackStub : public RiskAnalysisManagerCallbackStub {
79 public:
80 MockRiskAnalysisManagerCallbackStub() = default;
81 ~MockRiskAnalysisManagerCallbackStub() override = default;
ResponseSecurityModelResult(const std::string & devId,uint32_t modelId,std::string & result)82 int32_t ResponseSecurityModelResult(const std::string &devId, uint32_t modelId, std::string &result) override
83 {
84 return 0;
85 };
86 };
87 #endif
88 class MockSecurityCollectorManagerCallbackStub : public SecurityCollectorManagerCallbackStub {
89 public:
90 MockSecurityCollectorManagerCallbackStub() = default;
91 ~MockSecurityCollectorManagerCallbackStub() override = default;
92
OnNotify(const Event & event)93 int32_t OnNotify(const Event &event) override { return 0; };
94 };
95
96 class MockDataCollectManagerCallbackStub : public DataCollectManagerCallbackStub {
97 public:
98 MockDataCollectManagerCallbackStub() = default;
99 ~MockDataCollectManagerCallbackStub() override = default;
100
ResponseRiskData(std::string & devId,std::string & riskData,uint32_t status,const std::string & errMsg="")101 int32_t ResponseRiskData(std::string &devId, std::string &riskData, uint32_t status,
102 const std::string& errMsg = "") override { return 0; };
103 };
104
TestRequestRiskDataCallback(std::string &,std::string &,uint32_t,const std::string &)105 int32_t TestRequestRiskDataCallback(std::string &, std::string &, uint32_t, const std::string &)
106 {
107 return 0;
108 }
109
TestResultCallback(const std::string & devId,uint32_t modelId,const std::string & result)110 int32_t TestResultCallback(const std::string &devId, uint32_t modelId, const std::string &result)
111 {
112 return 0;
113 }
114
115
AcquireDataManagerFuzzTest(const uint8_t * data,size_t size)116 void AcquireDataManagerFuzzTest(const uint8_t* data, size_t size)
117 {
118 if (data == nullptr || size < sizeof(int64_t)) {
119 return;
120 }
121 size_t offset = 0;
122 int64_t eventId = *(reinterpret_cast<const int64_t *>(data + offset));
123 offset += sizeof(int64_t);
124 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
125 Security::SecurityCollector::Event event{eventId, string, string, string};
126 auto subscriber = std::make_shared<MockCollectorSubscriber>(event);
127 sptr<IRemoteObject> obj(new (std::nothrow) MockRemoteObject());
128 DataCollectManager::GetInstance().Subscribe(subscriber);
129 DataCollectManager::GetInstance().Unsubscribe(subscriber);
130 DataCollectManager::GetInstance().StartCollector(event, eventId);
131 DataCollectManager::GetInstance().StopCollector(event);
132 DataCollectManager::GetInstance().QuerySecurityEventConfig(string);
133 }
134
DataCollectManagerFuzzTest(const uint8_t * data,size_t size)135 void DataCollectManagerFuzzTest(const uint8_t* data, size_t size)
136 {
137 if (data == nullptr || size < sizeof(int64_t)) {
138 return;
139 }
140 FuzzedDataProvider fdp(data, size);
141 auto mute = std::make_shared<Security::SecurityGuard::EventMuteFilter>();
142 mute->eventId = fdp.ConsumeIntegral<int64_t>();
143 mute->type = static_cast<Security::SecurityGuard::EventMuteType>(fdp.ConsumeIntegral<int64_t>());
144 mute->eventGroup = fdp.ConsumeRandomLengthString(MAX_STRING_SIZE);
145 mute->mutes.emplace_back(fdp.ConsumeRandomLengthString(MAX_STRING_SIZE));
146 DataCollectManager::GetInstance().Mute(mute);
147 DataCollectManager::GetInstance().Unmute(mute);
148 auto func = [] (std::string &devId, std::string &riskData, uint32_t status,
149 const std::string &errMsg)-> int32_t {
150 return 0;
151 };
152 std::string string = fdp.ConsumeRandomLengthString(MAX_STRING_SIZE);
153 std::string string1 = fdp.ConsumeRandomLengthString(MAX_STRING_SIZE);
154 DataCollectManager::GetInstance().RequestSecurityEventInfo(string, string1, func);
155 }
AcquireDataManagerCallbackServiceFuzzTest(const uint8_t * data,size_t size)156 void AcquireDataManagerCallbackServiceFuzzTest(const uint8_t* data, size_t size)
157 {
158 if (data == nullptr || size < sizeof(int64_t)) {
159 return;
160 }
161 size_t offset = 0;
162 int64_t eventId = *(reinterpret_cast<const int64_t *>(data + offset));
163 offset += sizeof(int64_t);
164 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
165 Security::SecurityCollector::Event event{eventId, string, string, string};
166 AcquireDataManagerCallbackService service;
167 service.OnNotify({event});
168 }
169
AcquireDataManagerCallbackStubFuzzTest(const uint8_t * data,size_t size)170 void AcquireDataManagerCallbackStubFuzzTest(const uint8_t* data, size_t size)
171 {
172 if (data == nullptr || size < sizeof(int64_t)) {
173 return;
174 }
175 size_t offset = 0;
176 MockAcquireDataManagerCallbackStub stub;
177 MessageParcel datas;
178 MessageParcel reply;
179 MessageOption option;
180 int64_t int64 = *(reinterpret_cast<const int64_t *>(data + offset));
181 offset += sizeof(int64_t);
182 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
183 datas.WriteInterfaceToken(AcquireDataManagerCallbackStub::GetDescriptor());
184 datas.WriteInt64(int64);
185 datas.WriteString(string);
186 datas.WriteString(string);
187 datas.WriteString(string);
188 stub.OnRemoteRequest(AcquireDataManagerCallbackStub::CMD_DATA_SUBSCRIBE_CALLBACK, datas, reply, option);
189 }
190 #ifndef SECURITY_GUARD_TRIM_MODEL_ANALYSIS
RiskAnalysisManagerCallbackStubFuzzTest(const uint8_t * data,size_t size)191 void RiskAnalysisManagerCallbackStubFuzzTest(const uint8_t* data, size_t size)
192 {
193 if (data == nullptr || size < sizeof(uint32_t)) {
194 return;
195 }
196 size_t offset = 0;
197 MockRiskAnalysisManagerCallbackStub stub;
198 MessageParcel datas;
199 MessageParcel reply;
200 MessageOption option;
201 uint32_t code = *(reinterpret_cast<const uint32_t *>(data + offset));
202 offset += sizeof(uint32_t);
203 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
204 datas.WriteInterfaceToken(IRiskAnalysisManagerCallback::GetDescriptor());
205 datas.WriteUint32(*(reinterpret_cast<const uint32_t *>(data)));
206 datas.WriteString(string);
207 datas.WriteString(string);
208 stub.OnRemoteRequest(code, datas, reply, option);
209
210 ResultCallback callback;
211 RiskAnalysisManagerCallbackService service(callback);
212 service.ResponseSecurityModelResult(string, code, string);
213 service.callback_ = TestResultCallback;
214 service.ResponseSecurityModelResult(string, code, string);
215 }
216
RiskAnalysisManagerProxyFuzzTest(const uint8_t * data,size_t size)217 void RiskAnalysisManagerProxyFuzzTest(const uint8_t* data, size_t size)
218 {
219 if (data == nullptr || size < sizeof(uint32_t)) {
220 return;
221 }
222 size_t offset = 0;
223 sptr<IRemoteObject> obj(new (std::nothrow) MockRemoteObject());
224 ResultCallback func = [] (const std::string &devId, uint32_t modelId, const std::string &result) -> int32_t {
225 return 0;
226 };
227 sptr<RiskAnalysisManagerCallbackService> callback = new (std::nothrow) RiskAnalysisManagerCallbackService(func);
228 uint32_t uint32 = *(reinterpret_cast<const uint32_t *>(data));
229 offset += sizeof(uint32_t);
230 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
231 RiskAnalysisManagerProxy proxy{obj};
232 proxy.RequestSecurityModelResult(string, uint32, string, callback);
233 proxy.SetModelState(uint32, true);
234 }
235 #endif
CollectorManagerFuzzTest(const uint8_t * data,size_t size)236 void CollectorManagerFuzzTest(const uint8_t* data, size_t size)
237 {
238 if (data == nullptr || size < sizeof(int64_t)) {
239 return;
240 }
241 FuzzedDataProvider fdp(data, size);
242 Security::SecurityCollector::Event event{fdp.ConsumeIntegral<int64_t>(),
243 fdp.ConsumeRandomLengthString(MAX_STRING_SIZE), fdp.ConsumeRandomLengthString(MAX_STRING_SIZE),
244 fdp.ConsumeRandomLengthString(MAX_STRING_SIZE)};
245 auto subscriber = std::make_shared<MockCollectorSubscriber>(event);
246 std::vector<SecurityEventRuler> rulers{};
247 std::vector<SecurityEvent> events{};
248 SecurityCollectorSubscribeInfo subscribeInfo{};
249 CollectorManager::GetInstance().Subscribe(subscriber);
250 CollectorManager::GetInstance().Unsubscribe(subscriber);
251 CollectorManager::GetInstance().QuerySecurityEvent(rulers, events);
252 CollectorManager::GetInstance().CollectorStart(subscribeInfo);
253 CollectorManager::GetInstance().CollectorStop(subscribeInfo);
254
255 CollectorManager manager;
256 sptr<Security::SecurityCollector::SecurityCollectorManagerCallbackService> callback =
257 new (std::nothrow) Security::SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
258 manager.eventListeners_[subscriber] = callback;
259 manager.Subscribe(nullptr);
260 manager.Subscribe(subscriber);
261 manager.Unsubscribe(nullptr);
262 manager.Unsubscribe(subscriber);
263 SecurityCollectorEventMuteFilter filter {};
264 filter.eventId = fdp.ConsumeIntegral<int64_t>();
265 filter.type = static_cast<SecurityCollectorEventMuteType>(fdp.ConsumeIntegral<int64_t>());
266 filter.isSetMute = static_cast<bool>(fdp.ConsumeBool());
267 filter.mutes.emplace_back(fdp.ConsumeRandomLengthString(MAX_STRING_SIZE));
268 SecurityCollectorEventFilter subscribeMute(filter);
269 CollectorManager::GetInstance().Mute(subscribeMute, fdp.ConsumeRandomLengthString(MAX_STRING_SIZE));
270 CollectorManager::GetInstance().Unmute(subscribeMute, fdp.ConsumeRandomLengthString(MAX_STRING_SIZE));
271 }
272
DataCollectManagerCallbackStubFuzzTest(const uint8_t * data,size_t size)273 void DataCollectManagerCallbackStubFuzzTest(const uint8_t* data, size_t size)
274 {
275 if (data == nullptr || size < sizeof(uint32_t)) {
276 return;
277 }
278 size_t offset = 0;
279 MockDataCollectManagerCallbackStub stub;
280 MessageParcel datas;
281 MessageParcel reply;
282 MessageOption option;
283 uint32_t uint32 = *(reinterpret_cast<const uint32_t *>(data + offset));
284 offset += sizeof(uint32_t);
285 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
286 datas.WriteInterfaceToken(IDataCollectManagerCallback::GetDescriptor());
287 datas.WriteString(string);
288 datas.WriteUint32(uint32);
289 datas.WriteString(string);
290 stub.OnRemoteRequest(DataCollectManagerCallbackStub::CMD_SET_REQUEST_DATA, datas, reply, option);
291
292 RequestRiskDataCallback callback;
293 DataCollectManagerCallbackService service(callback);
294 service.ResponseRiskData(string, string, uint32, string);
295 service.callback_ = TestRequestRiskDataCallback;
296 service.ResponseRiskData(string, string, uint32, string);
297 }
298
DataCollectManagerProxyRequestDataSubmitFuzzTest(const uint8_t * data,size_t size)299 void DataCollectManagerProxyRequestDataSubmitFuzzTest(const uint8_t* data, size_t size)
300 {
301 if (data == nullptr || size < sizeof(int64_t)) {
302 return;
303 }
304 size_t offset = 0;
305 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
306 const std::string &errMsg) -> int32_t {
307 return 0;
308 };
309 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
310 int64_t int64 = *(reinterpret_cast<const int64_t *>(data));
311 offset += sizeof(int64_t);
312 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
313 DataCollectManagerProxy proxy{callback};
314 proxy.RequestDataSubmit(int64, string, string, string);
315 }
316
DataCollectManagerProxyRequestRiskDataFuzzTest(const uint8_t * data,size_t size)317 void DataCollectManagerProxyRequestRiskDataFuzzTest(const uint8_t* data, size_t size)
318 {
319 if (data == nullptr) {
320 return;
321 }
322 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
323 const std::string &errMsg) -> int32_t {
324 return 0;
325 };
326 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
327 std::string string(reinterpret_cast<const char*>(data), size);
328 sptr<IRemoteObject> objReq(new (std::nothrow) DataCollectManagerCallbackService(func));
329 DataCollectManagerProxy proxy{callback};
330 proxy.RequestRiskData(string, string, objReq);
331 }
332
DataCollectManagerProxySubscribeFuzzTest(const uint8_t * data,size_t size)333 void DataCollectManagerProxySubscribeFuzzTest(const uint8_t* data, size_t size)
334 {
335 if (data == nullptr) {
336 return;
337 }
338 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
339 const std::string &errMsg) -> int32_t {
340 return 0;
341 };
342 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
343 std::string string(reinterpret_cast<const char*>(data), size);
344 sptr<IRemoteObject> objSub(new (std::nothrow) SecurityCollectorManagerCallbackService(nullptr));
345 SecurityCollectorSubscribeInfo subscribeInfo{};
346 DataCollectManagerProxy proxy{callback};
347 proxy.Subscribe(subscribeInfo, objSub);
348 proxy.Unsubscribe(subscribeInfo, objSub);
349 }
350
DataCollectManagerProxyQuerySecurityEventFuzzTest(const uint8_t * data,size_t size)351 void DataCollectManagerProxyQuerySecurityEventFuzzTest(const uint8_t* data, size_t size)
352 {
353 if (data == nullptr) {
354 return;
355 }
356 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
357 const std::string &errMsg) -> int32_t {
358 return 0;
359 };
360 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
361 std::string eventGroup(reinterpret_cast<const char*>(data), size);
362 sptr<IRemoteObject> objQuery(new (std::nothrow) SecurityEventQueryCallbackService(nullptr));
363 std::vector<SecurityEventRuler> rulers{};
364 DataCollectManagerProxy proxy{callback};
365 proxy.QuerySecurityEvent(rulers, objQuery, eventGroup);
366 }
367
DataCollectManagerProxyCollectorStartStopFuzzTest(const uint8_t * data,size_t size)368 void DataCollectManagerProxyCollectorStartStopFuzzTest(const uint8_t* data, size_t size)
369 {
370 if (data == nullptr) {
371 return;
372 }
373 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
374 const std::string &errMsg) -> int32_t {
375 return 0;
376 };
377 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
378 std::string string(reinterpret_cast<const char*>(data), size);
379 sptr<IRemoteObject> objCollect(new (std::nothrow) SecurityCollectorManagerCallbackService(nullptr));
380 SecurityCollectorSubscribeInfo subscribeInfo{};
381 DataCollectManagerProxy proxy{callback};
382 proxy.CollectorStart(subscribeInfo, objCollect);
383 proxy.CollectorStop(subscribeInfo, objCollect);
384 }
385
DataCollectManagerProxyConfigUpdateFuzzTest(const uint8_t * data,size_t size)386 void DataCollectManagerProxyConfigUpdateFuzzTest(const uint8_t* data, size_t size)
387 {
388 if (data == nullptr) {
389 return;
390 }
391 RequestRiskDataCallback func = [] (std::string &devId, std::string &riskData, uint32_t status,
392 const std::string &errMsg) -> int32_t {
393 return 0;
394 };
395 sptr<DataCollectManagerCallbackService> callback = new (std::nothrow) DataCollectManagerCallbackService(func);
396 std::string string(reinterpret_cast<const char*>(data), size);
397 SecurityConfigUpdateInfo updateInfo{};
398 DataCollectManagerProxy proxy{callback};
399 proxy.ConfigUpdate(updateInfo);
400 }
401
SecurityCollectorManagerCallbackStubFuzzTest(const uint8_t * data,size_t size)402 void SecurityCollectorManagerCallbackStubFuzzTest(const uint8_t* data, size_t size)
403 {
404 if (data == nullptr || size < sizeof(uint32_t) + sizeof(uint32_t)) {
405 return;
406 }
407 size_t offset = 0;
408 MockSecurityCollectorManagerCallbackStub stub;
409 MessageParcel datas;
410 MessageParcel reply;
411 MessageOption option;
412 uint32_t code = *(reinterpret_cast<const uint32_t *>(data + offset));
413 offset += sizeof(uint32_t);
414 uint32_t uint32 = *(reinterpret_cast<const uint32_t *>(data + offset));
415 offset += sizeof(uint32_t);
416 std::string string(reinterpret_cast<const char*>(data + offset), size - offset);
417 datas.WriteInterfaceToken(ISecurityCollectorManagerCallback::GetDescriptor());
418 datas.WriteUint32(uint32);
419 datas.WriteString(string);
420 datas.WriteString(string);
421 datas.WriteString(string);
422 stub.OnRemoteRequest(code, datas, reply, option);
423 }
424
SecurityCollectorManagerProxyFuzzTest(const uint8_t * data,size_t size)425 void SecurityCollectorManagerProxyFuzzTest(const uint8_t* data, size_t size)
426 {
427 if (data == nullptr || size < sizeof(int64_t)) {
428 return;
429 }
430 sptr<IRemoteObject> obj(new (std::nothrow) MockRemoteObject());
431 sptr<Security::SecurityCollector::SecurityCollectorManagerCallbackService> callback =
432 new (std::nothrow) Security::SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
433 std::string string(reinterpret_cast<const char *>(data), size);
434 int64_t int64 = *(reinterpret_cast<const int64_t *>(data));
435 SecurityCollectorSubscribeInfo subscribeInfo({int64, string, string, string});
436 SecurityCollectorManagerProxy proxy{obj};
437 std::vector<SecurityEventRuler> rulers{};
438 std::vector<SecurityEvent> events{};
439 proxy.Subscribe(subscribeInfo, callback);
440 proxy.Unsubscribe(callback);
441 proxy.CollectorStart(subscribeInfo, callback);
442 proxy.CollectorStop(subscribeInfo, callback);
443 proxy.QuerySecurityEvent(rulers, events);
444 }
445
SecurityCollectorSubscribeInfoFuzzTest(const uint8_t * data,size_t size)446 void SecurityCollectorSubscribeInfoFuzzTest(const uint8_t* data, size_t size)
447 {
448 std::string string(reinterpret_cast<const char*>(data), size);
449 int64_t int64 = static_cast<int64_t>(size);
450 SecurityCollectorSubscribeInfo info;
451 Parcel parcel;
452 info.Marshalling(parcel);
453 info.Unmarshalling(parcel);
454 info.ReadFromParcel(parcel);
455
456 parcel.WriteInt64(int64);
457 info.ReadFromParcel(parcel);
458
459 parcel.WriteInt64(int64);
460 parcel.WriteBool(true);
461 info.ReadFromParcel(parcel);
462
463 parcel.WriteInt64(int64);
464 parcel.WriteBool(true);
465 parcel.WriteInt64(int64);
466 info.ReadFromParcel(parcel);
467
468 parcel.WriteInt64(int64);
469 parcel.WriteBool(true);
470 parcel.WriteInt64(int64);
471 parcel.WriteString(string);
472 info.ReadFromParcel(parcel);
473
474 parcel.WriteInt64(int64);
475 parcel.WriteBool(true);
476 parcel.WriteInt64(int64);
477 parcel.WriteString(string);
478 parcel.WriteString(string);
479 info.ReadFromParcel(parcel);
480
481 parcel.WriteInt64(int64);
482 parcel.WriteBool(true);
483 parcel.WriteInt64(int64);
484 parcel.WriteString(string);
485 parcel.WriteString(string);
486 parcel.WriteString(string);
487 info.ReadFromParcel(parcel);
488
489 info.Unmarshalling(parcel);
490 }
491
SecurityEventFuzzTest(const uint8_t * data,size_t size)492 void SecurityEventFuzzTest(const uint8_t* data, size_t size)
493 {
494 std::string string(reinterpret_cast<const char*>(data), size);
495 int64_t int64 = static_cast<int64_t>(size);
496 SecurityEvent event;
497 Parcel parcel;
498 event.Marshalling(parcel);
499 event.Unmarshalling(parcel);
500 event.ReadFromParcel(parcel);
501
502 parcel.WriteInt64(int64);
503 event.ReadFromParcel(parcel);
504
505 parcel.WriteInt64(int64);
506 parcel.WriteString(string);
507 event.ReadFromParcel(parcel);
508
509 parcel.WriteInt64(int64);
510 parcel.WriteString(string);
511 parcel.WriteString(string);
512 event.ReadFromParcel(parcel);
513
514 event.Unmarshalling(parcel);
515 }
516
SecurityEventRulerFuzzTest(const uint8_t * data,size_t size)517 void SecurityEventRulerFuzzTest(const uint8_t* data, size_t size)
518 {
519 std::string string(reinterpret_cast<const char*>(data), size);
520 int64_t int64 = static_cast<int64_t>(size);
521 SecurityEventRuler ruler;
522 Parcel parcel;
523 ruler.Marshalling(parcel);
524 ruler.Unmarshalling(parcel);
525 ruler.ReadFromParcel(parcel);
526
527 parcel.WriteInt64(int64);
528 ruler.ReadFromParcel(parcel);
529
530 parcel.WriteInt64(int64);
531 parcel.WriteString(string);
532 ruler.ReadFromParcel(parcel);
533
534 parcel.WriteInt64(int64);
535 parcel.WriteString(string);
536 parcel.WriteString(string);
537 ruler.ReadFromParcel(parcel);
538
539 parcel.WriteInt64(int64);
540 parcel.WriteString(string);
541 parcel.WriteString(string);
542 parcel.WriteString(string);
543 ruler.ReadFromParcel(parcel);
544
545 ruler.Unmarshalling(parcel);
546 }
547
548 } // namespace OHOS
549
550 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)551 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
552 {
553 /* Run your code on date */
554 OHOS::AcquireDataManagerFuzzTest(data, size);
555 OHOS::AcquireDataManagerCallbackServiceFuzzTest(data, size);
556 OHOS::AcquireDataManagerCallbackStubFuzzTest(data, size);
557 #ifndef SECURITY_GUARD_TRIM_MODEL_ANALYSIS
558 OHOS::RiskAnalysisManagerCallbackStubFuzzTest(data, size);
559 OHOS::RiskAnalysisManagerProxyFuzzTest(data, size);
560 #endif
561 OHOS::CollectorManagerFuzzTest(data, size);
562 OHOS::DataCollectManagerCallbackStubFuzzTest(data, size);
563 OHOS::DataCollectManagerProxyRequestDataSubmitFuzzTest(data, size);
564 OHOS::DataCollectManagerProxyRequestRiskDataFuzzTest(data, size);
565 OHOS::DataCollectManagerProxySubscribeFuzzTest(data, size);
566 OHOS::DataCollectManagerProxyQuerySecurityEventFuzzTest(data, size);
567 OHOS::DataCollectManagerProxyCollectorStartStopFuzzTest(data, size);
568 OHOS::DataCollectManagerProxyConfigUpdateFuzzTest(data, size);
569 OHOS::SecurityCollectorManagerCallbackStubFuzzTest(data, size);
570 OHOS::SecurityCollectorManagerProxyFuzzTest(data, size);
571 OHOS::SecurityCollectorSubscribeInfoFuzzTest(data, size);
572 OHOS::SecurityEventFuzzTest(data, size);
573 OHOS::SecurityEventRulerFuzzTest(data, size);
574 OHOS::DataCollectManagerFuzzTest(data, size);
575 return 0;
576 }