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 = 5;
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()->HasDataType(std::string(reinterpret_cast<const char *>(rawData), size));
210     PasteboardClient::GetInstance()->IsRemoteData();
211     std::string bundlename = pasteData2.GetBundleName();
212     PasteboardClient::GetInstance()->GetPasteData(pasteData2);
213     PasteboardClient::GetInstance()->GetDataSource(bundlename);
214 
215     std::string shareoption1;
216     PasteData::ShareOptionToString(ShareOption::InApp, shareoption1);
217     PasteData::ShareOptionToString(ShareOption::LocalDevice, shareoption1);
218     PasteData::ShareOptionToString(ShareOption::CrossDevice, shareoption1);
219     std::vector<std::uint8_t> buffer = {rawData, rawData + size};
220     pasteData2.Decode(buffer);
221     pasteData2.SetInvalid();
222     sptr<IRemoteObject> remoteObject = nullptr;
223     PasteboardClient::GetInstance()->LoadSystemAbilitySuccess(remoteObject);
224     PasteboardClient::GetInstance()->LoadSystemAbilityFail();
225     const wptr<IRemoteObject> object;
226     PasteboardClient::GetInstance()->OnRemoteSaDied(object);
227     PasteboardClient::GetInstance()->Clear();
228 }
229 
FuzzPastedataProperty(const uint8_t *rawData, size_t size)230 void FuzzPastedataProperty(const uint8_t *rawData, size_t size)
231 {
232     std::string str(reinterpret_cast<const char *>(rawData), size);
233     PasteDataProperty property1;
234     property1.tag ="tag1";
235     PasteDataProperty property2(property1);
236 
237     std::vector<std::uint8_t> buffer = {rawData, rawData + size};
238     property1.DecodeTag(buffer);
239     property1.Decode(buffer);
240 }
241 
FuzzPastedataRecord(const uint8_t *rawData, size_t size)242 void FuzzPastedataRecord(const uint8_t *rawData, size_t size)
243 {
244     std::string str(reinterpret_cast<const char *>(rawData), size);
245     std::vector<std::uint8_t> buffer = {rawData, rawData + size};
246     PasteDataRecord pasteDataRecord;
247 
248     std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
249     std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
250     std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
251     std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
252     std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
253 
254     pasteDataRecord.SetUri(uri);
255     const std::string htmlText2(reinterpret_cast<const char *>(rawData), size);
256     pasteDataRecord.NewHtmlRecord(htmlText2);
257     pasteDataRecord.NewWantRecord(want);
258     pasteDataRecord.NewPlaintTextRecord(str);
259     pasteDataRecord.NewPixelMapRecord(pixelMap);
260     pasteDataRecord.GetHtmlText();
261     pasteDataRecord.GetMimeType();
262     pasteDataRecord.GetPlainText();
263     pasteDataRecord.GetPixelMap();
264     pasteDataRecord.GetOrginUri();
265     pasteDataRecord.GetWant();
266     pasteDataRecord.GetCustomData();
267     pasteDataRecord.GetUri();
268     pasteDataRecord.ClearPixelMap();
269     pasteDataRecord.ConvertToText();
270     pasteDataRecord.Encode(buffer);
271     pasteDataRecord.Decode(buffer);
272     pasteDataRecord.Count();
273     pasteDataRecord.ReplaceShareUri(1);
274     pasteDataRecord.SetConvertUri(str),
275     pasteDataRecord.GetConvertUri();
276     pasteDataRecord.SetGrantUriPermission(false);
277     pasteDataRecord.HasGrantUriPermission();
278     pasteDataRecord.SetTextContent(str);
279     pasteDataRecord.GetTextContent();
280 }
281 
FuzzPastedataRecord002(const uint8_t *rawData, size_t size)282 void FuzzPastedataRecord002(const uint8_t *rawData, size_t size)
283 {
284     std::string str(reinterpret_cast<const char *>(rawData), size);
285     std::vector<std::uint8_t> buffer = {rawData, rawData + size};
286     PasteDataRecord pasteDataRecord;
287 
288     std::shared_ptr<std::string> htmlText = std::make_shared<std::string>(str);
289     std::shared_ptr<OHOS::AAFwk::Want> want = std::make_shared<OHOS::AAFwk::Want>();
290     std::shared_ptr<OHOS::Media::PixelMap> pixelMap = std::make_shared<PixelMap>();
291     std::shared_ptr<OHOS::Uri> uri = std::make_shared<Uri>(str);
292     std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
293 
294     Details details;
295     pasteDataRecord.SetDetails(details);
296     pasteDataRecord.GetDetails();
297     pasteDataRecord.SetSystemDefinedContent(details);
298     pasteDataRecord.GetSystemDefinedContent();
299     pasteDataRecord.SetUDType(0);
300     pasteDataRecord.GetUDType();
301 
302     std::vector<std::uint8_t> value = {rawData, rawData + size};
303     std::shared_ptr<PixelMap> pixelMap2 = std::make_shared<PixelMap>();
304     pasteDataRecord.Vector2PixelMap(value);
305     pasteDataRecord.PixelMap2Vector(pixelMap2);
306     std::string mimeType(reinterpret_cast<const char *>(rawData), size);
307     std::vector<uint8_t> arrayBuffer;
308     PasteDataRecord::NewKvRecord(mimeType, arrayBuffer);
309 
310     PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
311     std::shared_ptr<std::string> htmlText3 = std::make_shared<std::string>(str);
312     builder.SetHtmlText(htmlText3);
313     builder.SetMimeType(str);
314     builder.SetPlainText(htmlText3);
315     builder.SetUri(uri);
316     builder.SetPixelMap(pixelMap);
317     builder.SetWant(want);
318     builder.SetCustomData(customData);
319     builder.Build();
320 }
321 
FuzzMinecustomData(const uint8_t *rawData, size_t size)322 void FuzzMinecustomData(const uint8_t *rawData, size_t size)
323 {
324     std::string str(reinterpret_cast<const char *>(rawData), size);
325     std::string mimeType(reinterpret_cast<const char *>(rawData), size);
326     std::vector<uint8_t> arrayBuffer;
327     MineCustomData customData;
328 
329     std::vector<std::uint8_t> buffer = {rawData, rawData + size};
330     customData.Encode(buffer);
331     customData.Decode(buffer);
332     customData.Count();
333     customData.GetItemData();
334     customData.AddItemData(mimeType, arrayBuffer);
335 }
336 
FuzzPasteboardclientcreateData(const uint8_t *rawData, size_t size)337 void FuzzPasteboardclientcreateData(const uint8_t *rawData, size_t size)
338 {
339     std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
340     std::shared_ptr<PasteDataRecord> pasteDataRecord = std::make_shared<PasteDataRecord>();
341     uint32_t code = ConvertToUint32(rawData);
342     rawData = rawData + OFFSET;
343     size = size - OFFSET;
344     std::string str(reinterpret_cast<const char *>(rawData), size);
345 
346     std::shared_ptr<Want> want = std::make_shared<Want>();
347     std::string key = "id";
348     bool id = static_cast<bool>(*rawData);
349     Want wantIn = want->SetParam(key, id);
350 
351     if (code == RANDNUM_ZERO) {
352         pasteData = PasteboardClient::GetInstance()->CreateHtmlData(str);
353         pasteDataRecord = PasteboardClient::GetInstance()->CreateHtmlTextRecord(str);
354     } else {
355         pasteData = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<Want>(wantIn));
356         pasteDataRecord = PasteboardClient::GetInstance()->CreateWantRecord(std::make_shared<Want>(wantIn));
357     }
358     PasteboardClient::GetInstance()->SetPasteData(*pasteData);
359     std::set<Pattern> patternsToCheck = {Pattern::URL, Pattern::Number, static_cast<Pattern>(code)};
360     PasteboardClient::GetInstance()->DetectPatterns(patternsToCheck);
361 }
362 } // namespace OHOS
363 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)364 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
365 {
366     if (size < OHOS::THRESHOLD) {
367         return 0;
368     }
369     /* Run your code on data */
370     OHOS::FuzzPasteboardclient(data, size);
371     OHOS::FuzzPasteboardclient002(data, size);
372     OHOS::FuzzPasteboard(data, size);
373     OHOS::FuzzPastedata(data, size);
374     OHOS::FuzzPasteData002(data, size);
375     OHOS::FuzzMinecustomData(data, size);
376     OHOS::FuzzPastedataProperty(data, size);
377     OHOS::FuzzPastedataRecord(data, size);
378     OHOS::FuzzPastedataRecord002(data, size);
379     OHOS::FuzzPasteboardclientcreateData(data, size);
380     return 0;
381 }