1 /*
2  * Copyright (c) 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 "vcard_fuzzer.h"
17 
18 #include <cstddef>
19 #include <cstdint>
20 
21 #define private public
22 #define protected public
23 #include <fstream>
24 #include <sstream>
25 
26 #include "addcoreservicetoken_fuzzer.h"
27 #include "datashare_helper.h"
28 #include "datashare_predicates.h"
29 #include "event_runner.h"
30 #include "iservice_registry.h"
31 #include "system_ability_definition.h"
32 #include "telephony_errors.h"
33 #include "telephony_log_wrapper.h"
34 #include "vcard_constructor.h"
35 #include "vcard_manager.h"
36 #include "vcard_utils.h"
37 
38 using namespace OHOS::Telephony;
39 namespace OHOS {
40 constexpr const char *FILE_NAME = "example.vcf";
41 constexpr int32_t TYPE_NUM = 3;
42 
WriteTestData(const std::string & testStr)43 void WriteTestData(const std::string &testStr)
44 {
45     std::ofstream file;
46     file.open(FILE_NAME, std::ios::out);
47     if (file.is_open()) {
48         std::stringstream ss(testStr);
49         std::string line;
50 
51         while (std::getline(ss, line)) {
52             file << line << std::endl;
53         }
54     }
55     file.close();
56 }
57 
DecodeVcard(const uint8_t * data,size_t size)58 void DecodeVcard(const uint8_t *data, size_t size)
59 {
60     std::string inputString = R"(
61 BEGIN:VCARD
62 VERSION:2.0
63 N;CHARSET=UTF-8:刘;小;;;
64 EMAIL;TYPE=WORK:test@example.com
65 EMAIL;TYPE=HOME:home@example.com
66 EMAIL;TYPE=INTERNET:email@example.com
67 EMAIL;TYPE=PREF:preferred@example.com
68 EMAIL;TYPE=X-CUSTOM:custom@example.com
69 EMAIL;INTERNET:"llll"
70  <test@example.com>
71 END:VCARD
72 )";
73     WriteTestData(inputString);
74     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
75     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
76 }
77 
DecodeVcardData(const uint8_t * data,size_t size)78 void DecodeVcardData(const uint8_t *data, size_t size)
79 {
80     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
81     std::string inputString = R"(
82 BEGIN:VCARD
83 VERSION:2.0
84 N;CHARSET=UTF-8:刘;小;;;
85 EMAIL;TYPE=WORK:test@example.com
86 EMAIL;TYPE=HOME:home@example.com
87 EMAIL;TYPE=INTERNET:email@example.com
88 EMAIL;TYPE=PREF:preferred@example.com
89 EMAIL;TYPE=X-CUSTOM:custom@example.com
90 EMAIL;INTERNET:"llll"
91  <test@example.com>
92 END:VCARD
93 )" + fuzzdata;
94     WriteTestData(inputString);
95     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
96     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
97 }
98 
DecodeVcardRelation(const uint8_t * data,size_t size)99 void DecodeVcardRelation(const uint8_t *data, size_t size)
100 {
101     std::string inputString =
102         "BEGIN:VCARD\r\nVERSION:2.1\r\nX_OHOS_CUSTOM;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:relation;="
103         "E6=B5=8B=E8=AF=95;=E6=B5=8B=E8=AF=95=69=64;=E6=B5=8B=E8=AF=95=6E=61=6D=65\r\nX_OHOS_CUSTOM:"
104         "relation;realationName;labelId;labelName\r\nEND:VCARD\r\n";
105     WriteTestData(inputString);
106     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
107     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
108 }
109 
DecodeVcardRelationData(const uint8_t * data,size_t size)110 void DecodeVcardRelationData(const uint8_t *data, size_t size)
111 {
112     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
113     std::string inputString =
114         "BEGIN:VCARD\r\nVERSION:2.1\r\nX_OHOS_CUSTOM;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:relation;="
115         "E6=B5=8B=E8=AF=95;=E6=B5=8B=E8=AF=95=69=64;=E6=B5=8B=E8=AF=95=6E=61=6D=65\r\nX_OHOS_CUSTOM:"
116         "relation;realationName;labelId;labelName\r\nEND:VCARD\r\n" +
117         fuzzdata;
118     WriteTestData(inputString);
119     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
120     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
121 }
122 
ContructName(const uint8_t * data,size_t size)123 void ContructName(const uint8_t *data, size_t size)
124 {
125     auto nameData = std::make_shared<VCardNameData>();
126     std::string displayName(reinterpret_cast<const char *>(data), size);
127     nameData->displayName_ = displayName;
128     nameData->family_ = "测试F";
129     nameData->given_ = "wowowo";
130     nameData->middle_ = "测试M";
131     nameData->suffix_ = "wowowoSu";
132     nameData->prefix_ = "测试P";
133     nameData->phoneticFamily_ = "测试FP";
134     nameData->phoneticGiven_ = "测试GV";
135     nameData->phoneticMiddle_ = "wowowowMI";
136     auto contact = std::make_shared<VCardContact>();
137     contact->names_.push_back(nameData);
138     auto constructor = std::make_shared<VCardConstructor>();
139     auto value = constructor->ContactVCard(contact);
140 }
141 
ContructNameData(const uint8_t * data,size_t size)142 void ContructNameData(const uint8_t *data, size_t size)
143 {
144     if (data == nullptr || size == 0) {
145         return;
146     }
147     auto nameData = std::make_shared<VCardNameData>();
148     std::string displayName(reinterpret_cast<const char *>(data), size);
149     nameData->displayName_ = displayName;
150     std::string family(reinterpret_cast<const char *>(data), size);
151     nameData->family_ = family;
152     std::string given(reinterpret_cast<const char *>(data), size);
153     nameData->given_ = given;
154     std::string middle(reinterpret_cast<const char *>(data), size);
155     nameData->middle_ = middle;
156     std::string suffix(reinterpret_cast<const char *>(data), size);
157     nameData->suffix_ = suffix;
158     std::string prefix(reinterpret_cast<const char *>(data), size);
159     nameData->prefix_ = prefix;
160     std::string phoneticFamily(reinterpret_cast<const char *>(data), size);
161     nameData->phoneticFamily_ = phoneticFamily;
162     std::string phoneticGiven(reinterpret_cast<const char *>(data), size);
163     nameData->phoneticGiven_ = phoneticGiven;
164     std::string phoneticMiddle(reinterpret_cast<const char *>(data), size);
165     nameData->phoneticMiddle_ = phoneticMiddle;
166     auto contact = std::make_shared<VCardContact>();
167     contact->names_.push_back(nameData);
168     auto constructor = std::make_shared<VCardConstructor>();
169     auto value = constructor->ContactVCard(contact);
170 }
171 
ContructRelation(const uint8_t * data,size_t size)172 void ContructRelation(const uint8_t *data, size_t size)
173 {
174     auto data1 = std::make_shared<VCardRelationData>();
175     std::string test(reinterpret_cast<const char *>(data), size);
176     data1->relationName_ = test;
177     data1->labelId_ = "测试id";
178     data1->labelName_ = "测试name";
179     auto data2 = std::make_shared<VCardRelationData>();
180     data2->relationName_ = "realationName";
181     data2->labelId_ = "labelId";
182     data2->labelName_ = "labelName";
183     auto contact = std::make_shared<VCardContact>();
184     contact->relations_.push_back(data1);
185     contact->relations_.push_back(data2);
186     auto constructor = std::make_shared<VCardConstructor>();
187     auto value = constructor->ContactVCard(contact);
188 }
189 
ContructRelationData(const uint8_t * data,size_t size)190 void ContructRelationData(const uint8_t *data, size_t size)
191 {
192     auto data1 = std::make_shared<VCardRelationData>();
193     std::string test(reinterpret_cast<const char *>(data), size);
194     data1->relationName_ = test;
195     std::string testId(reinterpret_cast<const char *>(data), size);
196     data1->labelId_ = testId;
197     std::string testName(reinterpret_cast<const char *>(data), size);
198     data1->labelName_ = testName;
199     auto data2 = std::make_shared<VCardRelationData>();
200     std::string realationName(reinterpret_cast<const char *>(data), size);
201     data2->relationName_ = realationName;
202     std::string labelId(reinterpret_cast<const char *>(data), size);
203     data2->labelId_ = labelId;
204     std::string labelName(reinterpret_cast<const char *>(data), size);
205     data2->labelName_ = labelName;
206     auto contact = std::make_shared<VCardContact>();
207     contact->relations_.push_back(data1);
208     contact->relations_.push_back(data2);
209     auto constructor = std::make_shared<VCardConstructor>();
210     auto value = constructor->ContactVCard(contact);
211 }
212 
DecodeVcardRelationV30(const uint8_t * data,size_t size)213 void DecodeVcardRelationV30(const uint8_t *data, size_t size)
214 {
215     std::string inputString = "BEGIN:VCARD\r\nVERSION:3.0\r\nN:\r\nFN:\r\nTEL;TYPE=HOME:1202020\r\nTEL;TYPE=WORK,FAX:"
216                               "49305484\r\nTEL;TYPE=X-Work:503330303030\r\nEND:VCARD\r\n";
217     WriteTestData(inputString);
218     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
219     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
220 }
221 
DecodeVcardRelationDataV30(const uint8_t * data,size_t size)222 void DecodeVcardRelationDataV30(const uint8_t *data, size_t size)
223 {
224     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
225     std::string inputString = "BEGIN:VCARD\r\nVERSION:3.0\r\nN:\r\nFN:\r\nTEL;TYPE=HOME:1202020\r\nTEL;TYPE=WORK,FAX:"
226                               "49305484\r\nTEL;TYPE=X-Work:503330303030\r\nEND:VCARD\r\n" +
227                               fuzzdata;
228     WriteTestData(inputString);
229     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
230     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
231 }
232 
DecodeVcardRelationV40(const uint8_t * data,size_t size)233 void DecodeVcardRelationV40(const uint8_t *data, size_t size)
234 {
235     std::string inputString =
236         "BEGIN:VCARD\r\nVERSION:4.0\r\nN:test1;;;;\r\nFN:test1\r\nEND:VCARD\r\nBEGIN:VCARD\r\nVERSION:4.0\r\nN:test2;;;"
237         ";\r\nFN:test2\r\nEND:VCARD\r\nBEGIN:VCARD\r\nVERSION:4.0\r\nN:test3;;;;\r\nFN:test3\r\nEND:VCARD\r\n";
238     WriteTestData(inputString);
239     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
240     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
241 }
242 
DecodeVcardRelationDataV40(const uint8_t * data,size_t size)243 void DecodeVcardRelationDataV40(const uint8_t *data, size_t size)
244 {
245     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
246     std::string inputString =
247         "BEGIN:VCARD\r\nVERSION:4.0\r\nN:test1;;;;\r\nFN:test1\r\nEND:VCARD\r\nBEGIN:VCARD\r\nVERSION:4.0\r\nN:test2;;;"
248         ";\r\nFN:test2\r\nEND:VCARD\r\nBEGIN:VCARD\r\nVERSION:4.0\r\nN:test3;;;;\r\nFN:test3\r\nEND:VCARD\r\n" +
249         fuzzdata;
250     WriteTestData(inputString);
251     int32_t errorCode = static_cast<int32_t>(*data % TYPE_NUM);
252     VCardManager::GetInstance().Decode(FILE_NAME, errorCode);
253 }
254 
Import(const uint8_t * data,size_t size)255 void Import(const uint8_t *data, size_t size)
256 {
257     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
258     int32_t accountId = static_cast<int32_t>(*data);
259     VCardManager::GetInstance().Import(fuzzdata, accountId);
260 }
261 
ImportLock(const uint8_t * data,size_t size)262 void ImportLock(const uint8_t *data, size_t size)
263 {
264     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
265     int32_t accountId = static_cast<int32_t>(*data);
266     VCardManager::GetInstance().ImportLock(fuzzdata, nullptr, accountId);
267 }
268 
Export(const uint8_t * data,size_t size)269 void Export(const uint8_t *data, size_t size)
270 {
271     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
272     DataShare::DataSharePredicates predicates;
273     predicates.Between(Contact::ID, "0", "10");
274     int32_t cardType = static_cast<int32_t>(*data % TYPE_NUM);
275     VCardManager::GetInstance().Export(fuzzdata, predicates, cardType);
276 }
277 
ExportLock(const uint8_t * data,size_t size)278 void ExportLock(const uint8_t *data, size_t size)
279 {
280     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
281     DataShare::DataSharePredicates predicates;
282     predicates.Between(Contact::ID, "0", "10");
283     int32_t cardType = static_cast<int32_t>(*data % TYPE_NUM);
284     VCardManager::GetInstance().ExportLock(fuzzdata, nullptr, predicates, cardType);
285 }
286 
ExportToStr(const uint8_t * data,size_t size)287 void ExportToStr(const uint8_t *data, size_t size)
288 {
289     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
290     DataShare::DataSharePredicates predicates;
291     predicates.Between(Contact::ID, "0", "10");
292     int32_t cardType = static_cast<int32_t>(*data % TYPE_NUM);
293     VCardManager::GetInstance().ExportToStr(fuzzdata, predicates, cardType);
294     VCardManager::GetInstance().SetDataHelper(nullptr);
295 }
296 
VCardUtilsTest(const uint8_t * data,size_t size)297 void VCardUtilsTest(const uint8_t *data, size_t size)
298 {
299     std::string fuzzdata(reinterpret_cast<const char *>(data), size);
300     int32_t intPara = static_cast<int32_t>(*data);
301     char argument = static_cast<char>(*data);
302     std::string fileData(reinterpret_cast<const char *>(data), size);
303     std::string numberStr = std::to_string(intPara);
304     std::vector<std::string> records;
305     records.push_back(fileData);
306     VCardUtils::EqualsIgnoreCase(fuzzdata, fuzzdata);
307     VCardUtils::Trim(fuzzdata);
308     VCardUtils::ToUpper(fuzzdata);
309     VCardUtils::StartWith(fuzzdata, fuzzdata);
310     VCardUtils::EndWith(fuzzdata, fuzzdata);
311     VCardUtils::EncodeBase64(fuzzdata);
312     VCardUtils::DecodeBase64(fuzzdata);
313     VCardUtils::CreateFileName();
314     VCardUtils::SaveFile(fuzzdata, fuzzdata);
315     VCardUtils::IsPrintableAscii(fuzzdata);
316     VCardUtils::GetTypeFromImLabelId(numberStr);
317     VCardUtils::GetTypeFromPhoneLabelId(numberStr);
318     VCardUtils::GetImageType(fuzzdata);
319     VCardUtils::IsNum(fuzzdata);
320     VCardUtils::ConstructListFromValue(fuzzdata, fuzzdata);
321     VCardUtils::VcardtypeToInt(fuzzdata);
322     VCardUtils::FormatNumber(fuzzdata);
323     VCardUtils::GetPhoneNumberFormat(intPara);
324     VCardUtils::GetLabelIdFromImType(fuzzdata);
325     VCardUtils::HandleTypeAndLabel(intPara, fuzzdata, fuzzdata, fuzzdata);
326     VCardUtils::IsPrintableAscii(fuzzdata);
327     VCardUtils::IsPrintableAscii(argument);
328     VCardUtils::IsPrintableAscii(records);
329     VCardUtils::IsWrapPrintableAscii(records);
330     VCardUtils::TrimListToString(records);
331     VCardUtils::IsAllEmpty(records);
332     VCardUtils::HandleCh(argument, fuzzdata);
333 }
334 
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)335 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
336 {
337     DecodeVcard(data, size);
338     DecodeVcardData(data, size);
339     DecodeVcardRelation(data, size);
340     DecodeVcardRelationData(data, size);
341     ContructName(data, size);
342     ContructNameData(data, size);
343     ContructRelation(data, size);
344     ContructRelationData(data, size);
345     DecodeVcardRelationV30(data, size);
346     DecodeVcardRelationDataV30(data, size);
347     DecodeVcardRelationV40(data, size);
348     DecodeVcardRelationDataV40(data, size);
349     Import(data, size);
350     ImportLock(data, size);
351     Export(data, size);
352     ExportLock(data, size);
353     ExportToStr(data, size);
354     VCardUtilsTest(data, size);
355     return;
356 }
357 } // namespace OHOS
358 
359 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)360 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
361 {
362     /* Run your code on data */
363     OHOS::DoSomethingInterestingWithMyAPI(data, size);
364     return 0;
365 }
366