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_nlohmannjson_fuzzer.h"
18 #include "json_object.h"
19
20 namespace OHOS {
21 namespace DistributedHardware {
22
ToJsonDoubleNLFuzzTest(const uint8_t * data,size_t size)23 void ToJsonDoubleNLFuzzTest(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 }
36
ToJsonInt16NLFuzzTest(const uint8_t * data,size_t size)37 void ToJsonInt16NLFuzzTest(const uint8_t* data, size_t size)
38 {
39 if (data == nullptr || size < sizeof(int16_t)) {
40 return;
41 }
42
43 FuzzedDataProvider fdp(data, size);
44
45 JsonItemObject itemObject;
46 int16_t value = fdp.ConsumeIntegral<int16_t>();
47
48 ToJson(itemObject, value);
49 }
50
FromJsonDoubleNLFuzzTest(const uint8_t * data,size_t size)51 void FromJsonDoubleNLFuzzTest(const uint8_t* data, size_t size)
52 {
53 if (data == nullptr || size < sizeof(double) + sizeof(double)) {
54 return;
55 }
56
57 FuzzedDataProvider fdp(data, size);
58
59 JsonItemObject itemObject;
60 double result = fdp.ConsumeFloatingPoint<double>();
61
62 double testValue = fdp.ConsumeFloatingPoint<double>();
63 ToJson(itemObject, testValue);
64 FromJson(itemObject, result);
65 }
66
FromJsonBoolNLFuzzTest(const uint8_t * data,size_t size)67 void FromJsonBoolNLFuzzTest(const uint8_t* data, size_t size)
68 {
69 if (data == nullptr || size < sizeof(bool) + sizeof(bool)) {
70 return;
71 }
72
73 FuzzedDataProvider fdp(data, size);
74
75 JsonItemObject itemObject;
76 bool result = fdp.ConsumeBool();
77
78 bool testValue = fdp.ConsumeBool();
79 ToJson(itemObject, testValue);
80 FromJson(itemObject, result);
81 }
82
FromJsonUint8NLFuzzTest(const uint8_t * data,size_t size)83 void FromJsonUint8NLFuzzTest(const uint8_t* data, size_t size)
84 {
85 if (data == nullptr || size < sizeof(int32_t) + sizeof(uint8_t)) {
86 return;
87 }
88
89 FuzzedDataProvider fdp(data, size);
90
91 JsonItemObject itemObject;
92 uint8_t result = fdp.ConsumeIntegral<uint8_t>();
93
94 int32_t testValue = fdp.ConsumeIntegralInRange<int32_t>(
95 std::numeric_limits<uint8_t>::min(),
96 std::numeric_limits<uint8_t>::max());
97 ToJson(itemObject, testValue);
98 FromJson(itemObject, result);
99 }
100
FromJsonInt16NLFuzzTest(const uint8_t * data,size_t size)101 void FromJsonInt16NLFuzzTest(const uint8_t* data, size_t size)
102 {
103 if (data == nullptr || size < sizeof(int32_t) + sizeof(int16_t)) {
104 return;
105 }
106
107 FuzzedDataProvider fdp(data, size);
108
109 JsonItemObject itemObject;
110 int16_t result = fdp.ConsumeIntegralInRange<int16_t>(
111 std::numeric_limits<int16_t>::min(),
112 std::numeric_limits<int16_t>::max());
113
114 int32_t testValue = fdp.ConsumeIntegralInRange<int32_t>(
115 std::numeric_limits<int32_t>::min(),
116 std::numeric_limits<int32_t>::max());
117 ToJson(itemObject, testValue);
118 FromJson(itemObject, result);
119 }
120
IsNumberNLFuzzTest(const uint8_t * data,size_t size)121 void IsNumberNLFuzzTest(const uint8_t* data, size_t size)
122 {
123 (void)data;
124 (void)size;
125 JsonItemObject object;
126 object.IsNumber();
127 }
128
JsonItemObjectAssignmentNLFuzzTest(const uint8_t * data,size_t size)129 void JsonItemObjectAssignmentNLFuzzTest(const uint8_t* data, size_t size)
130 {
131 (void)data;
132 (void)size;
133 JsonItemObject sourceObj;
134 JsonItemObject targetObj = sourceObj;
135 }
136
PushBackDoubleNLFuzzTest(const uint8_t * data,size_t size)137 void PushBackDoubleNLFuzzTest(const uint8_t* data, size_t size)
138 {
139 if (data == nullptr || size < sizeof(double)) {
140 return;
141 }
142
143 FuzzedDataProvider fdp(data, size);
144 JsonItemObject object;
145
146 double value = fdp.ConsumeFloatingPoint<double>();
147 object.PushBack(value);
148 }
149
PushBackInt64NLFuzzTest(const uint8_t * data,size_t size)150 void PushBackInt64NLFuzzTest(const uint8_t* data, size_t size)
151 {
152 if (data == nullptr || size < sizeof(int64_t)) {
153 return;
154 }
155
156 FuzzedDataProvider fdp(data, size);
157 JsonItemObject object;
158
159 int64_t value = fdp.ConsumeIntegral<int64_t>();
160 object.PushBack(value);
161 }
162
PushBackStringNLFuzzTest(const uint8_t * data,size_t size)163 void PushBackStringNLFuzzTest(const uint8_t* data, size_t size)
164 {
165 if (data == nullptr || size == 0) {
166 return;
167 }
168
169 FuzzedDataProvider fdp(data, size);
170 JsonItemObject object;
171
172 std::string value = fdp.ConsumeRandomLengthString();
173 object.PushBack(value);
174 }
175
GetToDoubleNLFuzzTest(const uint8_t * data,size_t size)176 void GetToDoubleNLFuzzTest(const uint8_t* data, size_t size)
177 {
178 if (data == nullptr || size < sizeof(double)) {
179 return;
180 }
181
182 FuzzedDataProvider fdp(data, size);
183 JsonItemObject object;
184 double value = fdp.ConsumeFloatingPoint<double>();
185 object.GetTo(value);
186 }
187
GetToUint32NLFuzzTest(const uint8_t * data,size_t size)188 void GetToUint32NLFuzzTest(const uint8_t* data, size_t size)
189 {
190 if (data == nullptr || size < sizeof(uint32_t)) {
191 return;
192 }
193
194 FuzzedDataProvider fdp(data, size);
195 JsonItemObject object;
196 uint32_t value = fdp.ConsumeIntegral<uint32_t>();
197 object.GetTo(value);
198 }
199
GetToBoolNLFuzzTest(const uint8_t * data,size_t size)200 void GetToBoolNLFuzzTest(const uint8_t* data, size_t size)
201 {
202 if (data == nullptr || size < sizeof(bool)) {
203 return;
204 }
205
206 FuzzedDataProvider fdp(data, size);
207 JsonItemObject object;
208 bool value = fdp.ConsumeBool();
209 object.GetTo(value);
210 }
211 }
212 }
213
214 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)215 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
216 {
217 /* Run your code on data */
218 OHOS::DistributedHardware::ToJsonDoubleNLFuzzTest(data, size);
219 OHOS::DistributedHardware::ToJsonInt16NLFuzzTest(data, size);
220 OHOS::DistributedHardware::FromJsonDoubleNLFuzzTest(data, size);
221 OHOS::DistributedHardware::FromJsonBoolNLFuzzTest(data, size);
222 OHOS::DistributedHardware::FromJsonUint8NLFuzzTest(data, size);
223 OHOS::DistributedHardware::FromJsonInt16NLFuzzTest(data, size);
224 OHOS::DistributedHardware::IsNumberNLFuzzTest(data, size);
225 OHOS::DistributedHardware::JsonItemObjectAssignmentNLFuzzTest(data, size);
226 OHOS::DistributedHardware::PushBackDoubleNLFuzzTest(data, size);
227 OHOS::DistributedHardware::PushBackInt64NLFuzzTest(data, size);
228 OHOS::DistributedHardware::PushBackStringNLFuzzTest(data, size);
229 OHOS::DistributedHardware::GetToDoubleNLFuzzTest(data, size);
230 OHOS::DistributedHardware::GetToUint32NLFuzzTest(data, size);
231 OHOS::DistributedHardware::GetToBoolNLFuzzTest(data, size);
232
233 return 0;
234 }
235