1 /*
2 * Copyright (c) 2025 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 <fuzzer/FuzzedDataProvider.h>
17 #include "json_object_cjson_fuzzer.h"
18 #include "json_object.h"
19
20 namespace OHOS {
21 namespace DistributedHardware {
22
ToJsonDoubleFuzzTest(const uint8_t * data,size_t size)23 void ToJsonDoubleFuzzTest(const uint8_t* data, size_t size)
24 {
25 if (data == nullptr || size < sizeof(double)) {
26 return;
27 }
28
29 FuzzedDataProvider fdp(data, size);
30
31 JsonItemObject itemObject;
32 double value = fdp.ConsumeFloatingPoint<double>();
33
34 ToJson(itemObject, value);
35 }
ToJsonUint8FuzzTest(const uint8_t * data,size_t size)36 void ToJsonUint8FuzzTest(const uint8_t* data, size_t size)
37 {
38 if (data == nullptr || size < sizeof(uint8_t)) {
39 return;
40 }
41
42 FuzzedDataProvider fdp(data, size);
43
44 JsonItemObject itemObject;
45
46 uint8_t value = fdp.ConsumeIntegral<uint8_t>();
47
48 ToJson(itemObject, value);
49 }
50
ToJsonInt16FuzzTest(const uint8_t * data,size_t size)51 void ToJsonInt16FuzzTest(const uint8_t* data, size_t size)
52 {
53 if (data == nullptr || size < sizeof(int16_t)) {
54 return;
55 }
56
57 FuzzedDataProvider fdp(data, size);
58
59 JsonItemObject itemObject;
60 int16_t value = fdp.ConsumeIntegral<int16_t>();
61
62 ToJson(itemObject, value);
63 }
64
ToJsonUint16FuzzTest(const uint8_t * data,size_t size)65 void ToJsonUint16FuzzTest(const uint8_t* data, size_t size)
66 {
67 if (data == nullptr || size < sizeof(uint16_t)) {
68 return;
69 }
70
71 FuzzedDataProvider fdp(data, size);
72
73 JsonItemObject itemObject;
74 uint16_t value = fdp.ConsumeIntegral<uint16_t>();
75
76 ToJson(itemObject, value);
77 }
78
ToJsonUint64FuzzTest(const uint8_t * data,size_t size)79 void ToJsonUint64FuzzTest(const uint8_t* data, size_t size)
80 {
81 if (data == nullptr || size < sizeof(uint64_t)) {
82 return;
83 }
84
85 FuzzedDataProvider fdp(data, size);
86
87 JsonItemObject itemObject;
88 uint64_t value = fdp.ConsumeIntegral<uint64_t>();
89
90 ToJson(itemObject, value);
91 }
92
FromJsonDoubleFuzzTest(const uint8_t * data,size_t size)93 void FromJsonDoubleFuzzTest(const uint8_t* data, size_t size)
94 {
95 if (data == nullptr || size < sizeof(double) + sizeof(double)) {
96 return;
97 }
98
99 FuzzedDataProvider fdp(data, size);
100
101 JsonItemObject itemObject;
102 double result = fdp.ConsumeFloatingPoint<double>();
103
104 double testValue = fdp.ConsumeFloatingPoint<double>();
105 ToJson(itemObject, testValue);
106 FromJson(itemObject, result);
107 }
108
FromJsonBoolFuzzTest(const uint8_t * data,size_t size)109 void FromJsonBoolFuzzTest(const uint8_t* data, size_t size)
110 {
111 if (data == nullptr || size < sizeof(bool) + sizeof(bool)) {
112 return;
113 }
114
115 FuzzedDataProvider fdp(data, size);
116
117 JsonItemObject itemObject;
118 bool result = fdp.ConsumeBool();
119
120 bool testValue = fdp.ConsumeBool();
121 ToJson(itemObject, testValue);
122 FromJson(itemObject, result);
123 }
124
FromJsonUint8FuzzTest(const uint8_t * data,size_t size)125 void FromJsonUint8FuzzTest(const uint8_t* data, size_t size)
126 {
127 if (data == nullptr || size < sizeof(int32_t) + sizeof(uint8_t)) {
128 return;
129 }
130
131 FuzzedDataProvider fdp(data, size);
132
133 JsonItemObject itemObject;
134 uint8_t result = fdp.ConsumeIntegral<uint8_t>();
135
136 int32_t testValue = fdp.ConsumeIntegralInRange<int32_t>(
137 std::numeric_limits<uint8_t>::min(),
138 std::numeric_limits<uint8_t>::max());
139 ToJson(itemObject, testValue);
140 FromJson(itemObject, result);
141 }
142
FromJsonInt16FuzzTest(const uint8_t * data,size_t size)143 void FromJsonInt16FuzzTest(const uint8_t* data, size_t size)
144 {
145 if (data == nullptr || size < sizeof(int32_t) + sizeof(int16_t)) {
146 return;
147 }
148
149 FuzzedDataProvider fdp(data, size);
150
151 JsonItemObject itemObject;
152 int16_t result = fdp.ConsumeIntegralInRange<int16_t>(
153 std::numeric_limits<int16_t>::min(),
154 std::numeric_limits<int16_t>::max());
155
156 int32_t testValue = fdp.ConsumeIntegralInRange<int32_t>(
157 std::numeric_limits<int32_t>::min(),
158 std::numeric_limits<int32_t>::max());
159 ToJson(itemObject, testValue);
160 FromJson(itemObject, result);
161 }
162
FromJsonUint16FuzzTest(const uint8_t * data,size_t size)163 void FromJsonUint16FuzzTest(const uint8_t* data, size_t size)
164 {
165 if (data == nullptr || size < sizeof(int32_t) + sizeof(uint16_t)) {
166 return;
167 }
168
169 FuzzedDataProvider fdp(data, size);
170
171 JsonItemObject itemObject;
172 uint16_t result = fdp.ConsumeIntegralInRange<uint16_t>(
173 std::numeric_limits<uint16_t>::min(),
174 std::numeric_limits<uint16_t>::max());
175
176 int32_t testValue = fdp.ConsumeIntegralInRange<int32_t>(
177 std::numeric_limits<uint16_t>::min(),
178 std::numeric_limits<uint16_t>::max());
179 ToJson(itemObject, testValue);
180 FromJson(itemObject, result);
181 }
182
FromJsonInt32FuzzTest(const uint8_t * data,size_t size)183 void FromJsonInt32FuzzTest(const uint8_t* data, size_t size)
184 {
185 if (data == nullptr || size < sizeof(int32_t) + sizeof(int32_t)) {
186 return;
187 }
188
189 FuzzedDataProvider fdp(data, size);
190
191 JsonItemObject itemObject;
192 int32_t result = fdp.ConsumeIntegral<int32_t>();
193
194 int32_t testValue = fdp.ConsumeIntegral<int32_t>();
195 ToJson(itemObject, testValue);
196 FromJson(itemObject, result);
197 }
198
ToStringFuzzTest(const uint8_t * data,size_t size)199 void ToStringFuzzTest(const uint8_t* data, size_t size)
200 {
201 (void)data;
202 (void)size;
203
204 JsonItemObject object;
205
206 ToString(object);
207 }
208
IsArrayFuzzTest(const uint8_t * data,size_t size)209 void IsArrayFuzzTest(const uint8_t* data, size_t size)
210 {
211 (void)data;
212 (void)size;
213 JsonItemObject object;
214 object.IsArray();
215 }
216
IsObjectFuzzTest(const uint8_t * data,size_t size)217 void IsObjectFuzzTest(const uint8_t* data, size_t size)
218 {
219 (void)data;
220 (void)size;
221 JsonItemObject object;
222 object.IsObject();
223 }
224
JsonItemObjectAssignmentFuzzTest(const uint8_t * data,size_t size)225 void JsonItemObjectAssignmentFuzzTest(const uint8_t* data, size_t size)
226 {
227 (void)data;
228 (void)size;
229 JsonItemObject sourceObj;
230 JsonItemObject targetObj = sourceObj;
231 }
232
PushBackDoubleFuzzTest(const uint8_t * data,size_t size)233 void PushBackDoubleFuzzTest(const uint8_t* data, size_t size)
234 {
235 if (data == nullptr || size < sizeof(double)) {
236 return;
237 }
238
239 FuzzedDataProvider fdp(data, size);
240 JsonItemObject object;
241
242 double value = fdp.ConsumeFloatingPoint<double>();
243 object.PushBack(value);
244 }
245
PushBackInt64FuzzTest(const uint8_t * data,size_t size)246 void PushBackInt64FuzzTest(const uint8_t* data, size_t size)
247 {
248 if (data == nullptr || size < sizeof(int64_t)) {
249 return;
250 }
251
252 FuzzedDataProvider fdp(data, size);
253 JsonItemObject object;
254
255 int64_t value = fdp.ConsumeIntegral<int64_t>();
256 object.PushBack(value);
257 }
258
PushBackJsonItemObjectFuzzTest(const uint8_t * data,size_t size)259 void PushBackJsonItemObjectFuzzTest(const uint8_t* data, size_t size)
260 {
261 (void)data;
262 (void)size;
263 JsonItemObject object;
264 JsonItemObject objectTemp;
265 object.PushBack(objectTemp);
266 }
267
AddItemToArrayFuzzTest(const uint8_t * data,size_t size)268 void AddItemToArrayFuzzTest(const uint8_t* data, size_t size)
269 {
270 (void)data;
271 (void)size;
272 JsonItemObject object;
273 JsonItemObject objectTemp;
274 object.AddItemToArray(objectTemp);
275 }
276
GetToBoolFuzzTest(const uint8_t * data,size_t size)277 void GetToBoolFuzzTest(const uint8_t* data, size_t size)
278 {
279 if (data == nullptr || size < sizeof(bool)) {
280 return;
281 }
282
283 FuzzedDataProvider fdp(data, size);
284 JsonItemObject object;
285 bool value = fdp.ConsumeBool();
286 object.GetTo(value);
287 }
288
InitArrayFuzzTest(const uint8_t * data,size_t size)289 void InitArrayFuzzTest(const uint8_t* data, size_t size)
290 {
291 (void)data;
292 (void)size;
293 JsonItemObject object;
294 object.InitArray();
295 }
296
EraseFuzzTest(const uint8_t * data,size_t size)297 void EraseFuzzTest(const uint8_t* data, size_t size)
298 {
299 if (data == nullptr || size == 0) {
300 return;
301 }
302
303 FuzzedDataProvider fdp(data, size);
304 JsonItemObject object;
305 std::string key = fdp.ConsumeRandomLengthString();
306 object.Erase(key);
307 }
308
DuplicateFuzzTest(const uint8_t * data,size_t size)309 void DuplicateFuzzTest(const uint8_t* data, size_t size)
310 {
311 (void)data;
312 (void)size;
313 JsonObject object;
314 JsonObject objectTemp;
315 object.Duplicate(objectTemp);
316 }
317 }
318 }
319
320 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)321 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
322 {
323 /* Run your code on data */
324 OHOS::DistributedHardware::ToJsonDoubleFuzzTest(data, size);
325 OHOS::DistributedHardware::ToJsonUint8FuzzTest(data, size);
326 OHOS::DistributedHardware::ToJsonInt16FuzzTest(data, size);
327 OHOS::DistributedHardware::ToJsonUint16FuzzTest(data, size);
328 OHOS::DistributedHardware::ToJsonUint64FuzzTest(data, size);
329 OHOS::DistributedHardware::FromJsonDoubleFuzzTest(data, size);
330 OHOS::DistributedHardware::FromJsonBoolFuzzTest(data, size);
331 OHOS::DistributedHardware::FromJsonUint8FuzzTest(data, size);
332 OHOS::DistributedHardware::FromJsonInt16FuzzTest(data, size);
333 OHOS::DistributedHardware::FromJsonUint16FuzzTest(data, size);
334 OHOS::DistributedHardware::FromJsonInt32FuzzTest(data, size);
335 OHOS::DistributedHardware::ToStringFuzzTest(data, size);
336 OHOS::DistributedHardware::IsArrayFuzzTest(data, size);
337 OHOS::DistributedHardware::IsObjectFuzzTest(data, size);
338 OHOS::DistributedHardware::JsonItemObjectAssignmentFuzzTest(data, size);
339 OHOS::DistributedHardware::PushBackDoubleFuzzTest(data, size);
340 OHOS::DistributedHardware::PushBackInt64FuzzTest(data, size);
341 OHOS::DistributedHardware::PushBackJsonItemObjectFuzzTest(data, size);
342 OHOS::DistributedHardware::AddItemToArrayFuzzTest(data, size);
343 OHOS::DistributedHardware::GetToBoolFuzzTest(data, size);
344 OHOS::DistributedHardware::InitArrayFuzzTest(data, size);
345 OHOS::DistributedHardware::EraseFuzzTest(data, size);
346 OHOS::DistributedHardware::DuplicateFuzzTest(data, size);
347
348 return 0;
349 }
350