1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstddef>
17 #include <cstdint>
18 #include <fuzzer/FuzzedDataProvider.h>
19 #include <map>
20
21 #include "entity_recognition_observer.h"
22 #include "pasteboard_client.h"
23 #include "pasteboard_delay_getter.h"
24 #include "pasteboard_observer.h"
25 #include "pasteboard_service_loader.h"
26 #include "paste_data.h"
27 #include "paste_data_record.h"
28
29 using namespace OHOS::MiscServices;
30
31 namespace OHOS {
32 using namespace OHOS::Media;
33 using namespace OHOS::AAFwk;
34 constexpr size_t THRESHOLD = 5;
35 constexpr size_t OFFSET = 4;
36 constexpr size_t RANDNUM_ZERO = 0;
37 constexpr size_t LENGTH = 46;
38 constexpr uint32_t MAX_RECOGNITION_LENGTH = 1000;
39
ConvertToUint32(const uint8_t * ptr)40 uint32_t ConvertToUint32(const uint8_t *ptr)
41 {
42 if (ptr == nullptr) {
43 return 0;
44 }
45 uint32_t bigVar = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | (ptr[3]);
46 return bigVar;
47 }
48
49 class EntryGetterImpl : public UDMF::EntryGetter {
50 public:
GetValueByType(const std::string & utdId)51 UDMF::ValueType GetValueByType(const std::string &utdId) override
52 {
53 (void)utdId;
54 return nullptr;
55 }
56 };
57
58 class DelayGetterImpl : public PasteboardDelayGetter {
59 public:
GetPasteData(const std::string & type,PasteData & data)60 void GetPasteData(const std::string &type, PasteData &data) override
61 {
62 (void)type;
63 (void)data;
64 }
65
GetUnifiedData(const std::string & type,UDMF::UnifiedData & data)66 void GetUnifiedData(const std::string &type, UDMF::UnifiedData &data) override
67 {
68 (void)type;
69 (void)data;
70 }
71 };
72
FuzzPasteboardclient(const uint8_t * rawData,size_t size)73 void FuzzPasteboardclient(const uint8_t *rawData, size_t size)
74 {
75 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
76 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
77 uint32_t code = ConvertToUint32(rawData);
78 rawData = rawData + OFFSET;
79 size = size - OFFSET;
80 std::string str(reinterpret_cast<const char *>(rawData), size);
81
82 if (code == RANDNUM_ZERO) {
83 pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(str);
84 pasteDataRecord = PasteboardClient::GetInstance()->CreatePlainTextRecord(str);
85 } else {
86 pasteData = PasteboardClient::GetInstance()->CreateUriData(Uri(str));
87 pasteDataRecord = PasteboardClient::GetInstance()->CreateUriRecord(Uri(str));
88 }
89 pasteData->AddRecord(pasteDataRecord);
90 std::vector<uint8_t> buffer;
91 pasteData->Encode(buffer);
92
93 PasteData pasteData2;
94 pasteData2.Decode(buffer);
95 pasteData2.HasMimeType(std::string(reinterpret_cast<const char *>(rawData), size));
96 pasteData2.RemoveRecordAt(code);
97 pasteData2.ReplaceRecordAt(code, pasteDataRecord);
98
99 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
100 std::shared_ptr<PixelMap> pixelMap = std::make_shared<PixelMap>();
101 const std::vector<uint8_t> arrayBuffer = {rawData, rawData + size};
102 const OHOS::Uri uri = Uri(str);
103 PasteboardClient::GetInstance()->CreateHtmlTextRecord(str);
104 PasteboardClient::GetInstance()->CreateWantRecord(want);
105 PasteboardClient::GetInstance()->CreatePlainTextRecord(str);
106 PasteboardClient::GetInstance()->CreateUriRecord(uri);
107 PasteboardClient::GetInstance()->CreateKvRecord(str, arrayBuffer);
108 PasteboardClient::GetInstance()->CreateHtmlData(str);
109 PasteboardClient::GetInstance()->CreateWantData(want);
110 PasteboardClient::GetInstance()->CreatePlainTextData(str);
111 PasteboardClient::GetInstance()->CreatePixelMapData(pixelMap);
112 PasteboardClient::GetInstance()->CreateUriData(uri);
113 PasteboardClient::GetInstance()->CreateKvData(str, arrayBuffer);
114 }
115
FuzzPasteboardclient002(const uint8_t * rawData,size_t size)116 void FuzzPasteboardclient002(const uint8_t *rawData, size_t size)
117 {
118 PasteData pasteData3;
119 PasteboardClient::GetInstance()->GetPasteData(pasteData3);
120 std::shared_ptr<GetDataParams> params;
121 PasteboardClient::GetInstance()->GetDataWithProgress(pasteData3, params);
122 UDMF::UnifiedData unifiedData;
123 PasteboardClient::GetInstance()->GetUnifiedData(unifiedData);
124 PasteboardClient::GetInstance()->HasPasteData();
125 std::shared_ptr<PasteboardDelayGetter> delayGetter;
126 PasteboardClient::GetInstance()->SetPasteData(pasteData3, delayGetter);
127 PasteboardClient::GetInstance()->SetUnifiedData(unifiedData, delayGetter);
128 PasteboardObserverType type = PasteboardObserverType::OBSERVER_LOCAL;
129 sptr<PasteboardObserver> callback = new PasteboardObserver();
130 PasteboardClient::GetInstance()->Subscribe(type, callback);
131 sptr<EntityRecognitionObserver> observer = sptr<EntityRecognitionObserver>::MakeSptr();
132 PasteboardClient::GetInstance()->SubscribeEntityObserver(EntityType::ADDRESS, MAX_RECOGNITION_LENGTH, observer);
133 PasteboardClient::GetInstance()->AddPasteboardChangedObserver(callback);
134 PasteboardClient::GetInstance()->AddPasteboardEventObserver(callback);
135 PasteboardClient::GetInstance()->Unsubscribe(type, callback);
136 PasteboardClient::GetInstance()->UnsubscribeEntityObserver(EntityType::ADDRESS, MAX_RECOGNITION_LENGTH, observer);
137 PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(callback);
138 PasteboardClient::GetInstance()->RemovePasteboardEventObserver(callback);
139 const std::vector<uint32_t> tokenIds = {1, 2, 3};
140 PasteboardClient::GetInstance()->GetGlobalShareOption(tokenIds);
141 PasteboardClient::GetInstance()->RemoveGlobalShareOption(tokenIds);
142 const ShareOption shareOptions = ShareOption::LocalDevice;
143 PasteboardClient::GetInstance()->SetAppShareOptions(shareOptions);
144 PasteboardClient::GetInstance()->Clear();
145 uint32_t changeCount = 0;
146 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
147 }
148
FuzzPasteboardClient003(const uint8_t * rawData,size_t size)149 void FuzzPasteboardClient003(const uint8_t *rawData, size_t size)
150 {
151 constexpr uint32_t enumValueMax = 5;
152 FuzzedDataProvider fdp(rawData, size);
153
154 uint32_t dataId = fdp.ConsumeIntegral<uint32_t>();
155 uint32_t recordId = fdp.ConsumeIntegral<uint32_t>();
156 std::string utdId = fdp.ConsumeRandomLengthString();
157 PasteDataEntry entry;
158 entry.SetUtdId(utdId);
159 PasteboardClient::GetInstance()->GetRecordValueByType(0, 0, entry);
160
161 PasteData pasteData;
162 uint32_t index = fdp.ConsumeIntegral<uint32_t>();
163 std::shared_ptr<PasteboardDelayGetter> delayGetter = std::make_shared<DelayGetterImpl>();
164 std::map<uint32_t, std::shared_ptr<UDMF::EntryGetter>> entryGetters;
165 entryGetters.emplace(index, std::make_shared<EntryGetterImpl>());
166 PasteboardClient::GetInstance()->SetPasteData(pasteData, nullptr, entryGetters);
167 PasteboardClient::GetInstance()->SetPasteData(pasteData, delayGetter);
168 PasteboardClient::GetInstance()->SetPasteData(pasteData, delayGetter, entryGetters);
169
170 uint32_t type = fdp.ConsumeIntegralInRange<uint32_t>(0, enumValueMax);
171 PasteboardClient::GetInstance()->Unsubscribe(static_cast<PasteboardObserverType>(type), nullptr);
172
173 uint32_t tokenId = fdp.ConsumeIntegral<uint32_t>();
174 uint32_t shareOption = fdp.ConsumeIntegralInRange<uint32_t>(0, enumValueMax);
175 std::map<uint32_t, ShareOption> settings = {{ tokenId, static_cast<ShareOption>(shareOption) }};
176 PasteboardClient::GetInstance()->SetGlobalShareOption(settings);
177
178 PasteboardClient::GetInstance()->RemoveAppShareOptions();
179
180 std::string pasteId = fdp.ConsumeRandomLengthString();
181 std::string deviceId = fdp.ConsumeRandomLengthString();
182 PasteboardClient::GetInstance()->PasteStart(pasteId);
183 PasteboardClient::GetInstance()->PasteComplete(deviceId, pasteId);
184
185 auto dispObserver = fdp.ConsumeBool() ? nullptr : sptr<PasteboardDisposableObserver>::MakeSptr();
186 std::string bundle = fdp.ConsumeRandomLengthString();
187 DisposableType dispType = static_cast<DisposableType>(fdp.ConsumeIntegralInRange<uint32_t>(0, enumValueMax));
188 uint32_t maxLen = fdp.ConsumeIntegral<uint32_t>();
189 PasteboardClient::GetInstance()->SubscribeDisposableObserver(dispObserver, bundle, dispType, maxLen);
190 }
191
FuzzPasteboard(const uint8_t * rawData,size_t size)192 void FuzzPasteboard(const uint8_t *rawData, size_t size)
193 {
194 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
195 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
196 uint32_t code = ConvertToUint32(rawData);
197 rawData = rawData + OFFSET;
198 size = size - OFFSET;
199 std::string str(reinterpret_cast<const char *>(rawData), size);
200 uint32_t color[100] = { code };
201 InitializationOptions opts = { { 5, 7}, PixelFormat::ARGB_8888 };
202 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color)/sizeof(color[0]), opts);
203 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
204
205 std::vector<uint8_t> kvData(LENGTH);
206 kvData = { *rawData };
207 std::string mimetype = "image/jpg";
208
209 if (code == RANDNUM_ZERO) {
210 pasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
211 pasteDataRecord = PasteboardClient::GetInstance()->CreatePixelMapRecord(pixelMapIn);
212 } else {
213 pasteData = PasteboardClient::GetInstance()->CreateKvData(mimetype, kvData);
214 pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimetype, kvData);
215 }
216
217 pasteData->AddRecord(pasteDataRecord);
218 if (PasteboardClient::GetInstance()->HasPasteData()) {
219 PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(nullptr);
220 }
221 PasteboardClient::GetInstance()->SetPasteData(*pasteData);
222 uint32_t changeCount = 0;
223 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
224 std::set<Pattern> patternsToCheck = {Pattern::URL, Pattern::EMAIL_ADDRESS, static_cast<Pattern>(code)};
225 PasteboardClient::GetInstance()->DetectPatterns(patternsToCheck);
226 }
227
FuzzPastedata(const uint8_t * rawData,size_t size)228 void FuzzPastedata(const uint8_t *rawData, size_t size)
229 {
230 std::string str(reinterpret_cast<const char *>(rawData), size);
231 int32_t appIndex = 0;
232 PasteData pasteData2;
233 pasteData2.SetRemote(static_cast<bool>(*rawData));
234 pasteData2.SetLocalPasteFlag(static_cast<bool>(*rawData));
235 pasteData2.SetDraggedDataFlag(static_cast<bool>(*rawData));
236 pasteData2.SetOriginAuthority({ str, appIndex});
237 pasteData2.SetBundleInfo(str, appIndex);
238 pasteData2.SetTag(str);
239 pasteData2.SetTime(str);
240 pasteData2.SetDelayData(false);
241 pasteData2.IsDelayData();
242 pasteData2.IsValid();
243 pasteData2.IsRemote();
244 pasteData2.IsLocalPaste();
245 pasteData2.GetLocalOnly();
246 pasteData2.IsDraggedData();
247 pasteData2.GetDeviceId();
248 pasteData2.SetLocalOnly(false);
249 AAFwk::WantParams additions;
250 pasteData2.SetAdditions(additions);
251 pasteData2.GetTag();
252 ScreenEvent screenStatus = ScreenEvent::ScreenLocked;
253 pasteData2.SetScreenStatus(screenStatus);
254 pasteData2.GetScreenStatus();
255 pasteData2.GetTime();
256 pasteData2.SetOriginAuthority({ str, appIndex});
257 pasteData2.GetOriginAuthority();
258 pasteData2.SetBundleInfo(str, appIndex);
259 pasteData2.GetBundleName();
260 pasteData2.GetAppIndex();
261 pasteData2.GetDeviceId();
262 pasteData2.IsDraggedData();
263 pasteData2.GetLocalOnly();
264 pasteData2.AllRecords();
265 pasteData2.SetTokenId(0);
266 pasteData2.GetTokenId();
267 pasteData2.GetRecordAt(0);
268 }
269
FuzzPasteData002(const uint8_t * rawData,size_t size)270 void FuzzPasteData002(const uint8_t *rawData, size_t size)
271 {
272 std::string str(reinterpret_cast<const char *>(rawData), size);
273 PasteData pasteData2;
274 pasteData2.GetPrimaryText();
275 pasteData2.GetPrimaryWant();
276 pasteData2.GetPrimaryPixelMap();
277 pasteData2.GetPrimaryHtml();
278 std::shared_ptr<OHOS::AAFwk::Want> wantPtr = std::make_shared<OHOS::AAFwk::Want>();
279 pasteData2.AddWantRecord(wantPtr);
280 std::shared_ptr<PixelMap> pixelMap = std::make_shared<PixelMap>();
281 pasteData2.AddPixelMapRecord(pixelMap);
282 pasteData2.AddHtmlRecord(str);
283 PasteDataProperty property;
284 pasteData2.SetProperty(property);
285 pasteData2.GetProperty();
286 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
287 pasteData2.AddRecord(pasteDataRecord);
288
289 PasteData pasteData1 = pasteData2;
290 PasteboardClient::GetInstance()->SetPasteData(pasteData2);
291 uint32_t changeCount = 0;
292 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
293 PasteboardClient::GetInstance()->GetMimeTypes();
294 PasteboardClient::GetInstance()->HasDataType(std::string(reinterpret_cast<const char *>(rawData), size));
295 PasteboardClient::GetInstance()->IsRemoteData();
296 std::string bundlename = pasteData2.GetBundleName();
297 PasteboardClient::GetInstance()->GetPasteData(pasteData2);
298 std::shared_ptr<GetDataParams> params = std::make_shared<GetDataParams>();
299 PasteboardClient::GetInstance()->GetDataWithProgress(pasteData2, params);
300 PasteboardClient::GetInstance()->GetDataSource(bundlename);
301
302 std::string shareoption1;
303 PasteData::ShareOptionToString(ShareOption::InApp, shareoption1);
304 PasteData::ShareOptionToString(ShareOption::LocalDevice, shareoption1);
305 PasteData::ShareOptionToString(ShareOption::CrossDevice, shareoption1);
306 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
307 pasteData2.Decode(buffer);
308 pasteData2.SetInvalid();
309 sptr<IRemoteObject> remoteObject = nullptr;
310 PasteboardServiceLoader::GetInstance().LoadSystemAbilitySuccess(remoteObject);
311 PasteboardServiceLoader::GetInstance().LoadSystemAbilityFail();
312 const wptr<IRemoteObject> object;
313 PasteboardServiceLoader::GetInstance().OnRemoteSaDied(object);
314 PasteboardClient::GetInstance()->Clear();
315 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
316 }
317
FuzzPastedataProperty(const uint8_t * rawData,size_t size)318 void FuzzPastedataProperty(const uint8_t *rawData, size_t size)
319 {
320 std::string str(reinterpret_cast<const char *>(rawData), size);
321 PasteDataProperty property1;
322 property1.tag ="tag1";
323 PasteDataProperty property2(property1);
324
325 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
326 property1.Decode(buffer);
327 }
328
FuzzPastedataRecord(const uint8_t * rawData,size_t size)329 void FuzzPastedataRecord(const uint8_t *rawData, size_t size)
330 {
331 std::string str(reinterpret_cast<const char *>(rawData), size);
332 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
333 PasteDataRecord pasteDataRecord;
334
335 std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
336 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
337 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
338 std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
339 std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
340
341 pasteDataRecord.SetUri(uri);
342 const std::string htmlText2(reinterpret_cast<const char *>(rawData), size);
343 pasteDataRecord.NewHtmlRecord(htmlText2);
344 pasteDataRecord.NewWantRecord(want);
345 pasteDataRecord.NewPlainTextRecord(str);
346 pasteDataRecord.NewPixelMapRecord(pixelMap);
347 pasteDataRecord.GetHtmlTextV0();
348 pasteDataRecord.GetMimeType();
349 pasteDataRecord.GetPlainTextV0();
350 pasteDataRecord.GetPixelMapV0();
351 pasteDataRecord.GetOriginUri();
352 pasteDataRecord.GetWant();
353 pasteDataRecord.GetCustomData();
354 pasteDataRecord.GetUriV0();
355 pasteDataRecord.ClearPixelMap();
356 pasteDataRecord.ConvertToText();
357 pasteDataRecord.Encode(buffer);
358 pasteDataRecord.Decode(buffer);
359 pasteDataRecord.CountTLV();
360 pasteDataRecord.SetConvertUri(str),
361 pasteDataRecord.GetConvertUri();
362 pasteDataRecord.SetGrantUriPermission(false);
363 pasteDataRecord.HasGrantUriPermission();
364 pasteDataRecord.SetTextContent(str);
365 pasteDataRecord.GetTextContent();
366 }
367
FuzzPastedataRecord002(const uint8_t * rawData,size_t size)368 void FuzzPastedataRecord002(const uint8_t *rawData, size_t size)
369 {
370 std::string str(reinterpret_cast<const char *>(rawData), size);
371 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
372 PasteDataRecord pasteDataRecord;
373
374 std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
375 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
376 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
377 std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
378 std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
379
380 Details details;
381 pasteDataRecord.SetDetails(details);
382 pasteDataRecord.GetDetails();
383 pasteDataRecord.SetSystemDefinedContent(details);
384 pasteDataRecord.GetSystemDefinedContent();
385 pasteDataRecord.SetUDType(0);
386 pasteDataRecord.GetUDType();
387
388 std::vector<std::uint8_t> value = {rawData, rawData + size};
389 std::string mimeType(reinterpret_cast<const char *>(rawData), size);
390 std::vector<uint8_t> arrayBuffer;
391 PasteDataRecord::NewKvRecord(mimeType, arrayBuffer);
392
393 PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
394 std::shared_ptr<std::string> htmlText3 = std::make_shared<std::string>(str);
395 builder.SetHtmlText(htmlText3);
396 builder.SetMimeType(str);
397 builder.SetPlainText(htmlText3);
398 builder.SetUri(uri);
399 builder.SetPixelMap(pixelMap);
400 builder.SetWant(want);
401 builder.SetCustomData(customData);
402 builder.Build();
403 }
404
FuzzMinecustomData(const uint8_t * rawData,size_t size)405 void FuzzMinecustomData(const uint8_t *rawData, size_t size)
406 {
407 std::string str(reinterpret_cast<const char *>(rawData), size);
408 std::string mimeType(reinterpret_cast<const char *>(rawData), size);
409 std::vector<uint8_t> arrayBuffer;
410 MineCustomData customData;
411
412 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
413 customData.Encode(buffer);
414 customData.Decode(buffer);
415 customData.CountTLV();
416 customData.GetItemData();
417 customData.AddItemData(mimeType, arrayBuffer);
418 }
419
FuzzPasteboardclientcreateData(const uint8_t * rawData,size_t size)420 void FuzzPasteboardclientcreateData(const uint8_t *rawData, size_t size)
421 {
422 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
423 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
424 uint32_t code = ConvertToUint32(rawData);
425 rawData = rawData + OFFSET;
426 size = size - OFFSET;
427 std::string str(reinterpret_cast<const char *>(rawData), size);
428
429 std::shared_ptr<Want> want = std::make_shared<Want>();
430 std::string key = "id";
431 bool id = static_cast<bool>(*rawData);
432 Want wantIn = want->SetParam(key, id);
433
434 if (code == RANDNUM_ZERO) {
435 pasteData = PasteboardClient::GetInstance()->CreateHtmlData(str);
436 pasteDataRecord = PasteboardClient::GetInstance()->CreateHtmlTextRecord(str);
437 } else {
438 pasteData = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<Want>(wantIn));
439 pasteDataRecord = PasteboardClient::GetInstance()->CreateWantRecord(std::make_shared<Want>(wantIn));
440 }
441 PasteboardClient::GetInstance()->SetPasteData(*pasteData);
442 uint32_t changeCount = 0;
443 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
444 std::set<Pattern> patternsToCheck = {Pattern::URL, Pattern::NUMBER, static_cast<Pattern>(code)};
445 PasteboardClient::GetInstance()->DetectPatterns(patternsToCheck);
446 }
447 } // namespace OHOS
448 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)449 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
450 {
451 if (size < OHOS::THRESHOLD) {
452 return 0;
453 }
454 /* Run your code on data */
455 OHOS::FuzzPasteboardclient(data, size);
456 OHOS::FuzzPasteboardclient002(data, size);
457 OHOS::FuzzPasteboardClient003(data, size);
458 OHOS::FuzzPasteboard(data, size);
459 OHOS::FuzzPastedata(data, size);
460 OHOS::FuzzPasteData002(data, size);
461 OHOS::FuzzMinecustomData(data, size);
462 OHOS::FuzzPastedataProperty(data, size);
463 OHOS::FuzzPastedataRecord(data, size);
464 OHOS::FuzzPastedataRecord002(data, size);
465 OHOS::FuzzPasteboardclientcreateData(data, size);
466 return 0;
467 }