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