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 <map>
19
20 #include "pasteboard_client.h"
21 #include "entity_recognition_observer.h"
22 #include "pasteboard_observer.h"
23 #include "paste_data.h"
24 #include "paste_data_record.h"
25
26 using namespace OHOS::MiscServices;
27
28 namespace OHOS {
29 using namespace OHOS::Media;
30 using namespace OHOS::AAFwk;
31 constexpr size_t THRESHOLD = 5;
32 constexpr size_t OFFSET = 4;
33 constexpr size_t RANDNUM_ZERO = 0;
34 constexpr size_t LENGTH = 46;
35 constexpr uint32_t MAX_RECOGNITION_LENGTH = 1000;
36
ConvertToUint32(const uint8_t * ptr)37 uint32_t ConvertToUint32(const uint8_t *ptr)
38 {
39 if (ptr == nullptr) {
40 return 0;
41 }
42 uint32_t bigVar = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | (ptr[3]);
43 return bigVar;
44 }
45
FuzzPasteboardclient(const uint8_t * rawData,size_t size)46 void FuzzPasteboardclient(const uint8_t *rawData, size_t size)
47 {
48 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
49 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
50 uint32_t code = ConvertToUint32(rawData);
51 rawData = rawData + OFFSET;
52 size = size - OFFSET;
53 std::string str(reinterpret_cast<const char *>(rawData), size);
54
55 if (code == RANDNUM_ZERO) {
56 pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(str);
57 pasteDataRecord = PasteboardClient::GetInstance()->CreatePlainTextRecord(str);
58 } else {
59 pasteData = PasteboardClient::GetInstance()->CreateUriData(Uri(str));
60 pasteDataRecord = PasteboardClient::GetInstance()->CreateUriRecord(Uri(str));
61 }
62 pasteData->AddRecord(pasteDataRecord);
63 std::vector<uint8_t> buffer;
64 pasteData->Encode(buffer);
65
66 PasteData pasteData2;
67 pasteData2.Decode(buffer);
68 pasteData2.HasMimeType(std::string(reinterpret_cast<const char *>(rawData), size));
69 pasteData2.RemoveRecordAt(code);
70 pasteData2.ReplaceRecordAt(code, pasteDataRecord);
71
72 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
73 std::shared_ptr<PixelMap> pixelMap = std::make_shared<PixelMap>();
74 const std::vector<uint8_t> arrayBuffer = {rawData, rawData + size};
75 const OHOS::Uri uri = Uri(str);
76 PasteboardClient::GetInstance()->CreateHtmlTextRecord(str);
77 PasteboardClient::GetInstance()->CreateWantRecord(want);
78 PasteboardClient::GetInstance()->CreatePlainTextRecord(str);
79 PasteboardClient::GetInstance()->CreateUriRecord(uri);
80 PasteboardClient::GetInstance()->CreateKvRecord(str, arrayBuffer);
81 PasteboardClient::GetInstance()->CreateHtmlData(str);
82 PasteboardClient::GetInstance()->CreateWantData(want);
83 PasteboardClient::GetInstance()->CreatePlainTextData(str);
84 PasteboardClient::GetInstance()->CreatePixelMapData(pixelMap);
85 PasteboardClient::GetInstance()->CreateUriData(uri);
86 PasteboardClient::GetInstance()->CreateKvData(str, arrayBuffer);
87 }
88
FuzzPasteboardclient002(const uint8_t * rawData,size_t size)89 void FuzzPasteboardclient002(const uint8_t *rawData, size_t size)
90 {
91 PasteData pasteData3;
92 PasteboardClient::GetInstance()->GetPasteData(pasteData3);
93 std::shared_ptr<GetDataParams> params;
94 PasteboardClient::GetInstance()->GetDataWithProgress(pasteData3, params);
95 UDMF::UnifiedData unifiedData;
96 PasteboardClient::GetInstance()->GetUnifiedData(unifiedData);
97 PasteboardClient::GetInstance()->HasPasteData();
98 std::shared_ptr<PasteboardDelayGetter> delayGetter;
99 PasteboardClient::GetInstance()->SetPasteData(pasteData3, delayGetter);
100 PasteboardClient::GetInstance()->SetUnifiedData(unifiedData, delayGetter);
101 PasteboardObserverType type = PasteboardObserverType::OBSERVER_LOCAL;
102 sptr<PasteboardObserver> callback = new PasteboardObserver();
103 PasteboardClient::GetInstance()->Subscribe(type, callback);
104 sptr<EntityRecognitionObserver> observer = sptr<EntityRecognitionObserver>::MakeSptr();
105 PasteboardClient::GetInstance()->SubscribeEntityObserver(EntityType::ADDRESS, MAX_RECOGNITION_LENGTH, observer);
106 PasteboardClient::GetInstance()->AddPasteboardChangedObserver(callback);
107 PasteboardClient::GetInstance()->AddPasteboardEventObserver(callback);
108 PasteboardClient::GetInstance()->Unsubscribe(type, callback);
109 PasteboardClient::GetInstance()->UnsubscribeEntityObserver(EntityType::ADDRESS, MAX_RECOGNITION_LENGTH, observer);
110 PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(callback);
111 PasteboardClient::GetInstance()->RemovePasteboardEventObserver(callback);
112 const std::vector<uint32_t> tokenIds = {1, 2, 3};
113 PasteboardClient::GetInstance()->GetGlobalShareOption(tokenIds);
114 PasteboardClient::GetInstance()->RemoveGlobalShareOption(tokenIds);
115 const ShareOption shareOptions = ShareOption::LocalDevice;
116 PasteboardClient::GetInstance()->SetAppShareOptions(shareOptions);
117 PasteboardClient::GetInstance()->Clear();
118 uint32_t changeCount = 0;
119 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
120 }
121
FuzzPasteboard(const uint8_t * rawData,size_t size)122 void FuzzPasteboard(const uint8_t *rawData, size_t size)
123 {
124 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
125 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
126 uint32_t code = ConvertToUint32(rawData);
127 rawData = rawData + OFFSET;
128 size = size - OFFSET;
129 std::string str(reinterpret_cast<const char *>(rawData), size);
130 uint32_t color[100] = { code };
131 InitializationOptions opts = { { 5, 7}, PixelFormat::ARGB_8888 };
132 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color)/sizeof(color[0]), opts);
133 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
134
135 std::vector<uint8_t> kvData(LENGTH);
136 kvData = { *rawData };
137 std::string mimetype = "image/jpg";
138
139 if (code == RANDNUM_ZERO) {
140 pasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
141 pasteDataRecord = PasteboardClient::GetInstance()->CreatePixelMapRecord(pixelMapIn);
142 } else {
143 pasteData = PasteboardClient::GetInstance()->CreateKvData(mimetype, kvData);
144 pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimetype, kvData);
145 }
146
147 pasteData->AddRecord(pasteDataRecord);
148 if (PasteboardClient::GetInstance()->HasPasteData()) {
149 PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(nullptr);
150 }
151 PasteboardClient::GetInstance()->SetPasteData(*pasteData);
152 uint32_t changeCount = 0;
153 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
154 std::set<Pattern> patternsToCheck = {Pattern::URL, Pattern::EMAIL_ADDRESS, static_cast<Pattern>(code)};
155 PasteboardClient::GetInstance()->DetectPatterns(patternsToCheck);
156 }
157
FuzzPastedata(const uint8_t * rawData,size_t size)158 void FuzzPastedata(const uint8_t *rawData, size_t size)
159 {
160 std::string str(reinterpret_cast<const char *>(rawData), size);
161 PasteData pasteData2;
162 pasteData2.SetRemote(static_cast<bool>(*rawData));
163 pasteData2.SetLocalPasteFlag(static_cast<bool>(*rawData));
164 pasteData2.SetDraggedDataFlag(static_cast<bool>(*rawData));
165 pasteData2.SetOriginAuthority(str);
166 pasteData2.SetBundleName(str);
167 pasteData2.SetTag(str);
168 pasteData2.SetTime(str);
169 pasteData2.SetDelayData(false);
170 pasteData2.IsDelayData();
171 pasteData2.IsValid();
172 pasteData2.IsRemote();
173 pasteData2.IsLocalPaste();
174 pasteData2.GetLocalOnly();
175 pasteData2.IsDraggedData();
176 pasteData2.GetDeviceId();
177 pasteData2.SetLocalOnly(false);
178 AAFwk::WantParams additions;
179 pasteData2.SetAdditions(additions);
180 pasteData2.GetTag();
181 ScreenEvent screenStatus = ScreenEvent::ScreenLocked;
182 pasteData2.SetScreenStatus(screenStatus);
183 pasteData2.GetScreenStatus();
184 pasteData2.GetTime();
185 pasteData2.SetOriginAuthority(str);
186 pasteData2.GetOriginAuthority();
187 pasteData2.SetBundleName(str);
188 pasteData2.GetBundleName();
189 pasteData2.GetDeviceId();
190 pasteData2.IsDraggedData();
191 pasteData2.GetLocalOnly();
192 pasteData2.AllRecords();
193 pasteData2.SetTokenId(0);
194 pasteData2.GetTokenId();
195 pasteData2.GetRecordAt(0);
196 }
197
FuzzPasteData002(const uint8_t * rawData,size_t size)198 void FuzzPasteData002(const uint8_t *rawData, size_t size)
199 {
200 std::string str(reinterpret_cast<const char *>(rawData), size);
201 PasteData pasteData2;
202 pasteData2.GetPrimaryText();
203 pasteData2.GetPrimaryWant();
204 pasteData2.GetPrimaryPixelMap();
205 pasteData2.GetPrimaryHtml();
206 std::shared_ptr<OHOS::AAFwk::Want> wantPtr = std::make_shared<OHOS::AAFwk::Want>();
207 pasteData2.AddWantRecord(wantPtr);
208 std::shared_ptr<PixelMap> pixelMap = std::make_shared<PixelMap>();
209 pasteData2.AddPixelMapRecord(pixelMap);
210 pasteData2.AddHtmlRecord(str);
211 PasteDataProperty property;
212 pasteData2.SetProperty(property);
213 pasteData2.GetProperty();
214 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
215 pasteData2.AddRecord(pasteDataRecord);
216
217 PasteData pasteData1 = pasteData2;
218 PasteboardClient::GetInstance()->SetPasteData(pasteData2);
219 uint32_t changeCount = 0;
220 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
221 PasteboardClient::GetInstance()->GetMimeTypes();
222 PasteboardClient::GetInstance()->HasDataType(std::string(reinterpret_cast<const char *>(rawData), size));
223 PasteboardClient::GetInstance()->IsRemoteData();
224 std::string bundlename = pasteData2.GetBundleName();
225 PasteboardClient::GetInstance()->GetPasteData(pasteData2);
226 std::shared_ptr<GetDataParams> params = std::make_shared<GetDataParams>();
227 PasteboardClient::GetInstance()->GetDataWithProgress(pasteData2, params);
228 PasteboardClient::GetInstance()->GetDataSource(bundlename);
229
230 std::string shareoption1;
231 PasteData::ShareOptionToString(ShareOption::InApp, shareoption1);
232 PasteData::ShareOptionToString(ShareOption::LocalDevice, shareoption1);
233 PasteData::ShareOptionToString(ShareOption::CrossDevice, shareoption1);
234 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
235 pasteData2.Decode(buffer);
236 pasteData2.SetInvalid();
237 sptr<IRemoteObject> remoteObject = nullptr;
238 PasteboardClient::GetInstance()->LoadSystemAbilitySuccess(remoteObject);
239 PasteboardClient::GetInstance()->LoadSystemAbilityFail();
240 const wptr<IRemoteObject> object;
241 PasteboardClient::GetInstance()->OnRemoteSaDied(object);
242 PasteboardClient::GetInstance()->Clear();
243 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
244 }
245
FuzzPastedataProperty(const uint8_t * rawData,size_t size)246 void FuzzPastedataProperty(const uint8_t *rawData, size_t size)
247 {
248 std::string str(reinterpret_cast<const char *>(rawData), size);
249 PasteDataProperty property1;
250 property1.tag ="tag1";
251 PasteDataProperty property2(property1);
252
253 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
254 property1.Decode(buffer);
255 }
256
FuzzPastedataRecord(const uint8_t * rawData,size_t size)257 void FuzzPastedataRecord(const uint8_t *rawData, size_t size)
258 {
259 std::string str(reinterpret_cast<const char *>(rawData), size);
260 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
261 PasteDataRecord pasteDataRecord;
262
263 std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
264 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
265 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
266 std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
267 std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
268
269 pasteDataRecord.SetUri(uri);
270 const std::string htmlText2(reinterpret_cast<const char *>(rawData), size);
271 pasteDataRecord.NewHtmlRecord(htmlText2);
272 pasteDataRecord.NewWantRecord(want);
273 pasteDataRecord.NewPlainTextRecord(str);
274 pasteDataRecord.NewPixelMapRecord(pixelMap);
275 pasteDataRecord.GetHtmlText();
276 pasteDataRecord.GetMimeType();
277 pasteDataRecord.GetPlainText();
278 pasteDataRecord.GetPixelMap();
279 pasteDataRecord.GetOriginUri();
280 pasteDataRecord.GetWant();
281 pasteDataRecord.GetCustomData();
282 pasteDataRecord.GetUri();
283 pasteDataRecord.ClearPixelMap();
284 pasteDataRecord.ConvertToText();
285 pasteDataRecord.Encode(buffer);
286 pasteDataRecord.Decode(buffer);
287 pasteDataRecord.CountTLV();
288 pasteDataRecord.SetConvertUri(str),
289 pasteDataRecord.GetConvertUri();
290 pasteDataRecord.SetGrantUriPermission(false);
291 pasteDataRecord.HasGrantUriPermission();
292 pasteDataRecord.SetTextContent(str);
293 pasteDataRecord.GetTextContent();
294 }
295
FuzzPastedataRecord002(const uint8_t * rawData,size_t size)296 void FuzzPastedataRecord002(const uint8_t *rawData, size_t size)
297 {
298 std::string str(reinterpret_cast<const char *>(rawData), size);
299 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
300 PasteDataRecord pasteDataRecord;
301
302 std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
303 std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
304 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
305 std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
306 std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
307
308 Details details;
309 pasteDataRecord.SetDetails(details);
310 pasteDataRecord.GetDetails();
311 pasteDataRecord.SetSystemDefinedContent(details);
312 pasteDataRecord.GetSystemDefinedContent();
313 pasteDataRecord.SetUDType(0);
314 pasteDataRecord.GetUDType();
315
316 std::vector<std::uint8_t> value = {rawData, rawData + size};
317 std::string mimeType(reinterpret_cast<const char *>(rawData), size);
318 std::vector<uint8_t> arrayBuffer;
319 PasteDataRecord::NewKvRecord(mimeType, arrayBuffer);
320
321 PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
322 std::shared_ptr<std::string> htmlText3 = std::make_shared<std::string>(str);
323 builder.SetHtmlText(htmlText3);
324 builder.SetMimeType(str);
325 builder.SetPlainText(htmlText3);
326 builder.SetUri(uri);
327 builder.SetPixelMap(pixelMap);
328 builder.SetWant(want);
329 builder.SetCustomData(customData);
330 builder.Build();
331 }
332
FuzzMinecustomData(const uint8_t * rawData,size_t size)333 void FuzzMinecustomData(const uint8_t *rawData, size_t size)
334 {
335 std::string str(reinterpret_cast<const char *>(rawData), size);
336 std::string mimeType(reinterpret_cast<const char *>(rawData), size);
337 std::vector<uint8_t> arrayBuffer;
338 MineCustomData customData;
339
340 std::vector<std::uint8_t> buffer = {rawData, rawData + size};
341 customData.Encode(buffer);
342 customData.Decode(buffer);
343 customData.CountTLV();
344 customData.GetItemData();
345 customData.AddItemData(mimeType, arrayBuffer);
346 }
347
FuzzPasteboardclientcreateData(const uint8_t * rawData,size_t size)348 void FuzzPasteboardclientcreateData(const uint8_t *rawData, size_t size)
349 {
350 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
351 std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
352 uint32_t code = ConvertToUint32(rawData);
353 rawData = rawData + OFFSET;
354 size = size - OFFSET;
355 std::string str(reinterpret_cast<const char *>(rawData), size);
356
357 std::shared_ptr<Want> want = std::make_shared<Want>();
358 std::string key = "id";
359 bool id = static_cast<bool>(*rawData);
360 Want wantIn = want->SetParam(key, id);
361
362 if (code == RANDNUM_ZERO) {
363 pasteData = PasteboardClient::GetInstance()->CreateHtmlData(str);
364 pasteDataRecord = PasteboardClient::GetInstance()->CreateHtmlTextRecord(str);
365 } else {
366 pasteData = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<Want>(wantIn));
367 pasteDataRecord = PasteboardClient::GetInstance()->CreateWantRecord(std::make_shared<Want>(wantIn));
368 }
369 PasteboardClient::GetInstance()->SetPasteData(*pasteData);
370 uint32_t changeCount = 0;
371 PasteboardClient::GetInstance()->GetChangeCount(changeCount);
372 std::set<Pattern> patternsToCheck = {Pattern::URL, Pattern::NUMBER, static_cast<Pattern>(code)};
373 PasteboardClient::GetInstance()->DetectPatterns(patternsToCheck);
374 }
375 } // namespace OHOS
376 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)377 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
378 {
379 if (size < OHOS::THRESHOLD) {
380 return 0;
381 }
382 /* Run your code on data */
383 OHOS::FuzzPasteboardclient(data, size);
384 OHOS::FuzzPasteboardclient002(data, size);
385 OHOS::FuzzPasteboard(data, size);
386 OHOS::FuzzPastedata(data, size);
387 OHOS::FuzzPasteData002(data, size);
388 OHOS::FuzzMinecustomData(data, size);
389 OHOS::FuzzPastedataProperty(data, size);
390 OHOS::FuzzPastedataRecord(data, size);
391 OHOS::FuzzPastedataRecord002(data, size);
392 OHOS::FuzzPasteboardclientcreateData(data, size);
393 return 0;
394 }