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 "commonlib_fuzzer.h"
17
18 #include "clib_error.h"
19 #include "hc_string.h"
20 #include "json_utils.h"
21 #include "string_util.h"
22 #include "hc_tlv_parser.h"
23 #include "account_module_defines.h"
24 #include <cstdint>
25 #include <cstdlib>
26 #include <cstring>
27 #include <cstddef>
28 #include "securec.h"
29 #include "base/security/device_auth/common_lib/impl/src/hc_parcel.c"
30
31 namespace OHOS {
32 static const uint32_t TEST_BUFFER_SIZE = 16;
33 static const uint32_t TEST_MIN_ANONYMOUS_LEN = 12;
34 static const uint32_t TEST_LEN_TWO = 2;
35 static const uint32_t TEST_INVALID_BUFFER_SIZE = 0;
36 static const uint32_t TEST_LENGTH_ZERO = 0;
37 static const uint32_t TEST_SRC_DATA = 4;
38 static const uint32_t MAX_TLV_LENGTH = 32768;
39 static const uint32_t PARCEL_POS_0 = 0;
40 static const uint32_t PARCEL_POS_1 = 1;
41 const uint32_t PARCEL_UINT_MAX = 0xffffffffU;
42 static const char *TEST_JSON_STR = "{\"name\":\"test_name\", \"age\":18}";
43 static const char *TEST_JSON_STR_1 =
44 "{\"name\":\"test_name\", \"age\":18, \"useBigIntArr\":[\"userId\"], \"userId\":\"12343215234\"}";
45 static const char *TEST_JSON_STR_ARR = "[{\"name\":\"Tom1\",\"age\":18},{\"name\":\"Tom2\",\"age\":19}]";
46 static const char *TEST_STR = "test_str";
47 static const char TEST_CHAR = '0';
48
HcParcelNullPtrTest001()49 static void HcParcelNullPtrTest001()
50 {
51 HcParcel *parcelNull = nullptr;
52 ClearParcel(parcelNull);
53 ResetParcel(parcelNull, 1, 1);
54 HcParcel parcel;
55 void *dstNull = nullptr;
56 (void)ParcelEraseBlock(&parcel, 1, 1, dstNull);
57 (void)ParcelIncrease(parcelNull, 1);
58 (void)ParcelIncrease(&parcel, 0);
59 ParcelRecycle(parcelNull);
60 const void *srcNull = nullptr;
61 (void)ParcelWrite(&parcel, srcNull, 1);
62 (void)ParcelPopBack(parcelNull, 1);
63 (void)ParcelPopBack(&parcel, 0);
64 (void)ParcelPopFront(parcelNull, 1);
65 (void)ParcelPopFront(&parcel, 0);
66 DataRevert(parcelNull, 0);
67 (void)ParcelCopy(&parcel, parcelNull);
68 (void)ParcelReadParcel(&parcel, parcelNull, 0, HC_TRUE);
69 }
70
HcParcelNullPtrTest002()71 static void HcParcelNullPtrTest002()
72 {
73 HcParcel *parcelNull = nullptr;
74 HcParcel parcel;
75 (void)GetParcelIncreaseSize(parcelNull, 1);
76 parcel.allocUnit = 0;
77 (void)GetParcelIncreaseSize(&parcel, 1);
78 }
79
HcParcelInValidDataSizeTest001()80 static void HcParcelInValidDataSizeTest001()
81 {
82 HcParcel parcel;
83 parcel.beginPos = PARCEL_POS_1;
84 parcel.endPos = PARCEL_POS_0;
85 (void)GetParcelDataSize(&parcel);
86 (void)GetParcelLastChar(&parcel);
87 parcel.beginPos = PARCEL_POS_0;
88 parcel.endPos = PARCEL_POS_1;
89 parcel.allocUnit = 0;
90 ParcelRecycle(&parcel);
91 }
92
HcParcelInValidDataSizeTest002()93 static void HcParcelInValidDataSizeTest002()
94 {
95 HcParcel parcel;
96 uint32_t data = 1;
97 (void)ParcelEraseBlock(&parcel, 1, 0, &data);
98 (void)ParcelWriteRevert(&parcel, &data, 0);
99 parcel.length = 1;
100 (void)ParcelRealloc(&parcel, 0);
101 parcel.data = nullptr;
102 (void)ParcelIncrease(&parcel, 1);
103 }
104
HcParcelReadRevertTest001()105 static void HcParcelReadRevertTest001()
106 {
107 HcParcel parcel = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
108 HcParcel *parcelNull = nullptr;
109 int32_t int32Dst = 0;
110 uint32_t uint32Dst = 0;
111 int16_t int16Dst = 0;
112 uint16_t uint16Dst = 0;
113 uint16_t *uint16DstNull = nullptr;
114 int64_t int64Dst = 0;
115 uint64_t uint64Dst = 0;
116 (void)ParcelReadInt32Revert(&parcel, &int32Dst);
117 (void)ParcelReadUint32Revert(&parcel, &uint32Dst);
118 (void)ParcelReadInt16Revert(&parcel, &int16Dst);
119 (void)ParcelReadUint16Revert(&parcel, &uint16Dst);
120 (void)ParcelReadUint16Revert(&parcel, uint16DstNull);
121 (void)ParcelReadUint16Revert(parcelNull, &uint16Dst);
122 (void)ParcelReadUint16Revert(&parcel, &uint16Dst);
123 (void)ParcelReadInt64Revert(&parcel, &int64Dst);
124 (void)ParcelReadUint64Revert(&parcel, &uint64Dst);
125 DeleteParcel(&parcel);
126 }
127
HcParcelCreateTest001()128 static void HcParcelCreateTest001()
129 {
130 HcParcel parcelNullData = CreateParcel(TEST_INVALID_BUFFER_SIZE, PARCEL_DEFAULT_ALLOC_UNIT);
131 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, PARCEL_DEFAULT_ALLOC_UNIT);
132 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
133 (void)GetParcelDataSize(nullptr);
134 (void)GetParcelDataSize(&parcelWithData);
135 (void)GetParcelData(nullptr);
136 (void)GetParcelData(&parcelWithData);
137 (void)GetParcelLastChar(nullptr);
138 (void)GetParcelLastChar(&parcelWithData);
139 ClearParcel(&parcelWithData);
140 ResetParcel(&parcelWithData, TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
141 DeleteParcel(nullptr);
142 DeleteParcel(&parcelNullData);
143 DeleteParcel(&parcelWithData);
144 }
145
HcParcelReadTest001()146 static void HcParcelReadTest001()
147 {
148 uint32_t num = 0;
149 uint32_t uintDataSize = sizeof(uint32_t);
150 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
151 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
152 (void)ParcelReadWithoutPopData(&parcelWithData, &num, uintDataSize);
153 (void)ParcelRead(nullptr, nullptr, uintDataSize);
154 (void)ParcelRead(&parcelWithData, &num, uintDataSize);
155 parcelWithData.beginPos = PARCEL_UINT_MAX - uintDataSize;
156 (void)ParcelRead(&parcelWithData, &num, uintDataSize);
157 parcelWithData.beginPos = 0;
158 parcelWithData.endPos = 0;
159 (void)ParcelRead(&parcelWithData, &num, uintDataSize);
160 DeleteParcel(&parcelWithData);
161 }
162
HcParcelEraseBlockTest001()163 static void HcParcelEraseBlockTest001()
164 {
165 uint32_t start = 0;
166 uint32_t num = 0;
167 uint32_t uintDataSize = sizeof(uint32_t);
168 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
169 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
170 (void)ParcelEraseBlock(nullptr, start, uintDataSize, &num);
171 (void)ParcelEraseBlock(&parcelWithData, PARCEL_UINT_MAX, uintDataSize, &num);
172 (void)ParcelEraseBlock(&parcelWithData, PARCEL_UINT_MAX - uintDataSize, uintDataSize, &num);
173 (void)ParcelEraseBlock(&parcelWithData, start, uintDataSize, &num);
174 DeleteParcel(&parcelWithData);
175 }
176
HcParcelRevertTest001()177 static void HcParcelRevertTest001()
178 {
179 uint32_t num = 0;
180 uint32_t uintDataSize = sizeof(uint32_t);
181 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
182 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
183 (void)ParcelReadRevert(&parcelWithData, &num, TEST_LENGTH_ZERO);
184 (void)ParcelReadRevert(&parcelWithData, &num, uintDataSize);
185 (void)ParcelWriteRevert(nullptr, &num, uintDataSize);
186 DeleteParcel(&parcelWithData);
187 }
188
HcParcelReadWrite001()189 static void HcParcelReadWrite001()
190 {
191 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
192 int32_t srcInt = 0;
193 int32_t dstInt = 0;
194 (void)ParcelWriteInt32(&parcelWithData, srcInt);
195 (void)ParcelReadInt32(&parcelWithData, &dstInt);
196 uint32_t srcUint32 = 0;
197 uint32_t dstUint32 = 0;
198 (void)ParcelWriteUint32(&parcelWithData, srcUint32);
199 (void)ParcelReadUint32(&parcelWithData, &dstUint32);
200 short srcInt16 = 0;
201 short dstInt16 = 0;
202 (void)ParcelWriteInt16(&parcelWithData, srcInt16);
203 (void)ParcelReadInt16(&parcelWithData, &dstInt16);
204 uint16_t srcUint16 = 0;
205 uint16_t dstUint16 = 0;
206 (void)ParcelWriteUint16(&parcelWithData, srcUint16);
207 (void)ParcelReadUint16(&parcelWithData, &dstUint16);
208 char srcInt8 = 0;
209 char dstInt8 = 0;
210 (void)ParcelWriteInt8(&parcelWithData, srcInt8);
211 (void)ParcelReadInt8(&parcelWithData, &dstInt8);
212 uint8_t srcUint8 = 0;
213 uint8_t dstUint8 = 0;
214 (void)ParcelWriteUint8(&parcelWithData, srcUint8);
215 (void)ParcelReadUint8(&parcelWithData, &dstUint8);
216 int64_t srcInt64 = 0;
217 int64_t dstInt64 = 0;
218 (void)ParcelWriteInt64(&parcelWithData, srcInt64);
219 (void)ParcelReadInt64(&parcelWithData, &dstInt64);
220 uint64_t srcUint64 = 0;
221 uint64_t dstUint64 = 0;
222 (void)ParcelWriteUint64(&parcelWithData, srcUint64);
223 (void)ParcelReadUint64(&parcelWithData, &dstUint64);
224 DeleteParcel(&parcelWithData);
225 }
226
HcParcelRealloc001()227 static void HcParcelRealloc001()
228 {
229 HcParcel parcelSrc = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
230 HcParcel parcelDst = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
231 (void)ParcelWriteInt32(&parcelSrc, TEST_SRC_DATA);
232 uint32_t data01 = 0;
233 uint64_t data02 = 0;
234 uint32_t validLen = sizeof(data01);
235 uint32_t invalidLen = sizeof(data02);
236 (void)ParcelReadParcel(nullptr, nullptr, validLen, HC_FALSE);
237 (void)ParcelReadParcel(&parcelSrc, &parcelDst, invalidLen, HC_FALSE);
238 (void)ParcelReadParcel(&parcelSrc, &parcelDst, TEST_LENGTH_ZERO, HC_FALSE);
239 (void)ParcelReadParcel(&parcelSrc, &parcelDst, validLen, HC_FALSE);
240 DeleteParcel(&parcelSrc);
241 DeleteParcel(&parcelDst);
242 }
243
HcParcelCopy001()244 static void HcParcelCopy001()
245 {
246 HcParcel parcelSrc = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
247 HcParcel parcelDst = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
248 (void)ParcelCopy(nullptr, nullptr);
249 (void)ParcelCopy(&parcelSrc, &parcelDst);
250 (void)ParcelWriteInt32(&parcelSrc, TEST_SRC_DATA);
251 (void)ParcelCopy(&parcelSrc, &parcelDst);
252 DeleteParcel(&parcelSrc);
253 DeleteParcel(&parcelDst);
254 }
255
HcParcelReadWriteRevert001()256 static void HcParcelReadWriteRevert001()
257 {
258 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
259 int32_t srcInt = 0;
260 int32_t dstInt = 0;
261 (void)ParcelWriteInt32Revert(&parcelWithData, srcInt);
262 (void)ParcelReadInt32Revert(&parcelWithData, &dstInt);
263 uint32_t srcUint32 = 0;
264 uint32_t dstUint32 = 0;
265 (void)ParcelWriteUint32Revert(&parcelWithData, srcUint32);
266 (void)ParcelReadUint32Revert(&parcelWithData, &dstUint32);
267 short srcInt16 = 0;
268 short dstInt16 = 0;
269 (void)ParcelWriteInt16Revert(&parcelWithData, srcInt16);
270 (void)ParcelReadInt16Revert(&parcelWithData, &dstInt16);
271 uint16_t srcUint16 = 0;
272 uint16_t dstUint16 = 0;
273 (void)ParcelWriteUint16Revert(&parcelWithData, srcUint16);
274 (void)ParcelReadUint16Revert(&parcelWithData, &dstUint16);
275 char srcInt8 = 0;
276 char dstInt8 = 0;
277 (void)ParcelWriteInt8Revert(&parcelWithData, srcInt8);
278 (void)ParcelReadInt8Revert(&parcelWithData, &dstInt8);
279 uint8_t srcUint8 = 0;
280 uint8_t dstUint8 = 0;
281 (void)ParcelWriteUint8Revert(&parcelWithData, srcUint8);
282 (void)ParcelReadUint8Revert(&parcelWithData, &dstUint8);
283 int64_t srcInt64 = 0;
284 int64_t dstInt64 = 0;
285 (void)ParcelWriteInt64Revert(&parcelWithData, srcInt64);
286 (void)ParcelReadInt64Revert(&parcelWithData, &dstInt64);
287 uint64_t srcUint64 = 0;
288 uint64_t dstUint64 = 0;
289 (void)ParcelWriteUint64Revert(&parcelWithData, srcUint64);
290 (void)ParcelReadUint64Revert(&parcelWithData, &dstUint64);
291 DeleteParcel(&parcelWithData);
292 }
293
HcParcelPop001()294 static void HcParcelPop001()
295 {
296 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
297 (void)ParcelWriteInt32(&parcelWithData, TEST_SRC_DATA);
298 (void)ParcelPopBack(&parcelWithData, sizeof(uint32_t));
299 (void)ParcelPopBack(&parcelWithData, sizeof(uint32_t));
300 (void)ParcelWriteInt32(&parcelWithData, TEST_SRC_DATA);
301 (void)ParcelPopFront(&parcelWithData, sizeof(uint32_t));
302 (void)ParcelPopFront(&parcelWithData, sizeof(uint32_t));
303 DeleteParcel(&parcelWithData);
304 }
305
HcStringTest001()306 static void HcStringTest001()
307 {
308 HcString selfStr = CreateString();
309 HcString srcStr = CreateString();
310 (void)StringSetPointer(&srcStr, TEST_STR);
311 (void)StringAppend(nullptr, srcStr);
312 (void)StringAppend(&selfStr, srcStr);
313 (void)StringAppendPointer(nullptr, TEST_STR);
314 (void)StringAppendPointer(&selfStr, TEST_STR);
315 (void)StringAppendChar(nullptr, TEST_CHAR);
316 (void)StringAppendChar(&selfStr, TEST_CHAR);
317 (void)StringSet(nullptr, srcStr);
318 (void)StringSet(&selfStr, srcStr);
319 (void)StringSetPointer(nullptr, TEST_STR);
320 (void)StringSetPointer(&selfStr, TEST_STR);
321 const char *retStr = StringGet(nullptr);
322 retStr = StringGet(&selfStr);
323 uint32_t retLen = StringLength(nullptr);
324 retLen = StringLength(&selfStr);
325 DeleteString(&selfStr);
326 retLen = StringLength(&selfStr);
327 DeleteString(&srcStr);
328 }
329
HcCreateJsonTest001()330 static void HcCreateJsonTest001()
331 {
332 CJson *invalidJson = CreateJsonFromString(nullptr);
333 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
334 invalidJson = DuplicateJson(nullptr);
335 FreeJson(validJson);
336 }
337
HcDeleteJsonTest001()338 static void HcDeleteJsonTest001()
339 {
340 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
341 CJson *jsonItem = DetachItemFromJson(nullptr, "age");
342 jsonItem = DetachItemFromJson(validJson, "age");
343 DeleteItemFromJson(nullptr, "name");
344 DeleteItemFromJson(validJson, "name");
345 DeleteAllItemExceptOne(nullptr, "name");
346 DeleteAllItemExceptOne(validJson, "name");
347 DeleteAllItem(nullptr);
348 DeleteAllItem(validJson);
349 FreeJson(validJson);
350 }
351
HcJsonGetTest001()352 static void HcJsonGetTest001()
353 {
354 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
355 char *jsonStr = PackJsonToString(nullptr);
356 jsonStr = PackJsonToString(validJson);
357 FreeJsonString(jsonStr);
358 int32_t itemNum = GetItemNum(nullptr);
359 itemNum = GetItemNum(validJson);
360 const char *itemKey = GetItemKey(nullptr);
361 itemKey = GetItemKey(validJson);
362 CJson *jsonObj = GetObjFromJson(nullptr, "name");
363 jsonObj = GetObjFromJson(validJson, "name");
364 jsonObj = GetItemFromArray(nullptr, 0);
365 jsonObj = GetItemFromArray(validJson, 0);
366 FreeJson(validJson);
367 }
368
HcJsonGetTest002()369 static void HcJsonGetTest002()
370 {
371 CJson *validJson = CreateJsonFromString(TEST_JSON_STR);
372 const char *strObj = GetStringFromJson(nullptr, "name");
373 strObj = GetStringFromJson(validJson, "name");
374 char byteData[] = "test_byte";
375 (void)GetByteFromJson(nullptr, "name", nullptr, sizeof(byteData));
376 (void)GetByteFromJson(validJson, "gender", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
377 (void)GetByteFromJson(validJson, "name", reinterpret_cast<uint8_t *>(byteData), TEST_LENGTH_ZERO);
378 int32_t valueInt32 = 0;
379 (void)GetIntFromJson(nullptr, "age", &valueInt32);
380 uint32_t valueUint32 = 0;
381 (void)GetUnsignedIntFromJson(nullptr, "age", &valueUint32);
382 int64_t valueInt64 = 0;
383 (void)GetInt64FromJson(nullptr, "age", &valueInt64);
384 bool valueBool = false;
385 (void)GetBoolFromJson(nullptr, "age", &valueBool);
386 CJson *jsonObj = GetObjFromJson(validJson, "name");
387 (void)GetStringValue(jsonObj);
388 FreeJson(validJson);
389 }
390
HcJsonGetTest003()391 static void HcJsonGetTest003()
392 {
393 CJson *jsonObj = CreateJson();
394 int data = 1;
395 uint8_t value = 0;
396 (void)AddIntToJson(jsonObj, "name", data);
397 (void)GetUint8FromJson(nullptr, "name", &value);
398 (void)GetUint8FromJson(jsonObj, nullptr, &value);
399 (void)GetUint8FromJson(jsonObj, "name", nullptr);
400 (void)GetUint8FromJson(jsonObj, "name", &value);
401 DeleteItemFromJson(jsonObj, "name");
402 (void)GetUint8FromJson(jsonObj, "name", &value);
403 (void)GetBoolFromJson(jsonObj, nullptr, nullptr);
404 (void)GetBoolFromJson(jsonObj, "name", nullptr);
405 (void)GetUnsignedIntFromJson(jsonObj, nullptr, nullptr);
406 (void)GetUnsignedIntFromJson(jsonObj, "name", nullptr);
407 (void)GetIntFromJson(jsonObj, nullptr, nullptr);
408 (void)GetIntFromJson(jsonObj, "name", nullptr);
409 (void)GetByteFromJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
410 (void)GetByteFromJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
411 (void)GetStringFromJson(jsonObj, nullptr);
412 FreeJsonString(nullptr);
413 CJson *retJson = DetachItemFromJson(jsonObj, nullptr);
414 retJson = GetObjFromJson(jsonObj, nullptr);
415 DeleteAllItemExceptOne(jsonObj, nullptr);
416 DeleteItemFromJson(jsonObj, nullptr);
417 retJson = DuplicateJson(nullptr);
418 FreeJson(jsonObj);
419 }
420
HcJsonGetTest004()421 static void HcJsonGetTest004()
422 {
423 CJson *jsonObj = CreateJson();
424 uint32_t byteLen = 0;
425 char byteData[] = "test_byte";
426 (void)AddByteToJson(jsonObj, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
427 (void)GetByteLenFromJson(nullptr, "name", &byteLen);
428 (void)GetByteLenFromJson(jsonObj, nullptr, &byteLen);
429 (void)GetByteLenFromJson(jsonObj, "name", nullptr);
430 (void)GetByteLenFromJson(jsonObj, "name", &byteLen);
431 (void)GetByteLenFromJson(jsonObj, "test", &byteLen);
432 FreeJson(jsonObj);
433 }
434
HcJsonAddTest001()435 static void HcJsonAddTest001()
436 {
437 CJson *jsonArr = CreateJsonFromString(TEST_JSON_STR_ARR);
438 CJson *childObj = CreateJsonFromString(TEST_JSON_STR);
439 (void)AddObjToJson(nullptr, "name", nullptr);
440 (void)AddObjToJson(jsonArr, "gender", childObj);
441 (void)AddObjToJson(jsonArr, "name", childObj);
442 (void)AddObjToArray(nullptr, childObj);
443 (void)AddObjToArray(childObj, jsonArr);
444 (void)AddObjToArray(jsonArr, childObj);
445 (void)AddStringToArray(nullptr, TEST_STR);
446 (void)AddStringToArray(childObj, TEST_STR);
447 (void)AddStringToArray(jsonArr, TEST_STR);
448 (void)AddStringToJson(nullptr, "name", TEST_STR);
449 (void)AddStringToJson(childObj, "gender", TEST_STR);
450 (void)AddStringToJson(childObj, "name", TEST_STR);
451 FreeJson(jsonArr);
452 }
453
HcJsonAddTest002()454 static void HcJsonAddTest002()
455 {
456 CJson *childObj = CreateJsonFromString(TEST_JSON_STR);
457 char byteData[] = "test_byte";
458 (void)AddByteToJson(nullptr, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
459 (void)AddByteToJson(childObj, "gender", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
460 (void)AddByteToJson(childObj, "name", reinterpret_cast<uint8_t *>(byteData), sizeof(byteData));
461 (void)AddBoolToJson(nullptr, "name", false);
462 (void)AddBoolToJson(childObj, "gender", false);
463 (void)AddBoolToJson(childObj, "name", false);
464 int32_t valueInt32 = 0;
465 (void)AddIntToJson(nullptr, "name", valueInt32);
466 (void)AddIntToJson(childObj, "gender", valueInt32);
467 (void)AddIntToJson(childObj, "name", valueInt32);
468 int64_t valueInt64 = 0;
469 (void)AddInt64StringToJson(nullptr, "name", valueInt64);
470 (void)AddInt64StringToJson(childObj, "name", valueInt64);
471 const char *const strArr[] = {"first test data", "second test data"};
472 (void)AddStringArrayToJson(nullptr, "name", strArr, sizeof(strArr) / sizeof(strArr[0]));
473 (void)AddStringArrayToJson(childObj, "name", strArr, sizeof(strArr) / sizeof(strArr[0]));
474 }
475
HcJsonAddTest003()476 static void HcJsonAddTest003()
477 {
478 CJson *jsonObj = CreateJson();
479 (void)AddBoolToJson(jsonObj, nullptr, false);
480 (void)AddByteToJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
481 (void)AddByteToJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
482 (void)AddIntToJson(jsonObj, nullptr, 0);
483 (void)AddStringArrayToJson(jsonObj, nullptr, nullptr, TEST_BUFFER_SIZE);
484 (void)AddStringArrayToJson(jsonObj, "name", nullptr, TEST_BUFFER_SIZE);
485 (void)AddStringToJson(jsonObj, nullptr, nullptr);
486 (void)AddStringToJson(jsonObj, "name", nullptr);
487 (void)AddStringToArray(jsonObj, nullptr);
488 (void)AddObjToArray(jsonObj, nullptr);
489 (void)AddObjToJson(jsonObj, nullptr, nullptr);
490 (void)AddObjToJson(jsonObj, "name", nullptr);
491 FreeJson(jsonObj);
492 }
493
HcClearJsonTest001()494 static void HcClearJsonTest001()
495 {
496 CJson *jsonObj = CreateJsonFromString(TEST_JSON_STR);
497 ClearSensitiveStringInJson(nullptr, "name");
498 ClearSensitiveStringInJson(jsonObj, "gender");
499 ClearSensitiveStringInJson(jsonObj, "name");
500 ClearSensitiveStringInJson(jsonObj, nullptr);
501 FreeJson(jsonObj);
502 }
503
HcClearJsonTest002()504 static void HcClearJsonTest002()
505 {
506 CJson *jsonObj = CreateJsonFromString(TEST_JSON_STR);
507 char *jsonStr = PackJsonToString(jsonObj);
508 ClearAndFreeJsonString(nullptr);
509 ClearAndFreeJsonString(jsonStr);
510 FreeJson(jsonObj);
511 }
512
HcClearJsonTest003()513 static void HcClearJsonTest003()
514 {
515 CJson *jsonObj = CreateJsonFromString(TEST_JSON_STR_1);
516 char *jsonStr = PackJsonToString(jsonObj);
517 ClearAndFreeJsonString(nullptr);
518 ClearAndFreeJsonString(jsonStr);
519 FreeJson(jsonObj);
520 }
521
HcStringUtilTest001()522 static void HcStringUtilTest001()
523 {
524 const uint8_t byteData[] = "1234";
525 const char hexData[] = "ABCD";
526 const char invalidData[] = "GHJK";
527 const char inValidLenData[] = "ABC";
528 uint32_t byteSize = sizeof(byteData);
529 char hexStr[TEST_BUFFER_SIZE] = { 0 };
530 (void)ByteToHexString(nullptr, byteSize, hexStr, TEST_BUFFER_SIZE);
531 (void)ByteToHexString(byteData, byteSize, nullptr, TEST_BUFFER_SIZE);
532 (void)ByteToHexString(byteData, byteSize, hexStr, TEST_LENGTH_ZERO);
533 (void)ByteToHexString(byteData, byteSize, hexStr, TEST_BUFFER_SIZE);
534 uint8_t byteStr[TEST_BUFFER_SIZE] = { 0 };
535 (void)HexStringToByte(nullptr, byteStr, TEST_BUFFER_SIZE);
536 (void)HexStringToByte(hexData, nullptr, TEST_BUFFER_SIZE);
537 (void)HexStringToByte(inValidLenData, byteStr, TEST_BUFFER_SIZE);
538 (void)HexStringToByte(hexData, byteStr, TEST_LENGTH_ZERO);
539 (void)HexStringToByte(invalidData, byteStr, TEST_BUFFER_SIZE);
540 (void)HexStringToByte(hexData, byteStr, TEST_BUFFER_SIZE);
541 const char intStr[] = "10";
542 int64_t int64Res = StringToInt64(intStr);
543 int64Res = StringToInt64(nullptr);
544 }
545
HcStringUtilTest002()546 static void HcStringUtilTest002()
547 {
548 const char oriData[] = "abcd";
549 const char inValidData[] = "";
550 char *desData = nullptr;
551 (void)ToUpperCase(nullptr, &desData);
552 (void)ToUpperCase(oriData, nullptr);
553 (void)DeepCopyString(nullptr, &desData);
554 (void)DeepCopyString(inValidData, &desData);
555 }
556
HcStringUtilTest003()557 static void HcStringUtilTest003()
558 {
559 const uint8_t byteData[] = "1234";
560 uint32_t byteSize = sizeof(byteData);
561 const char tag[] = "TEST";
562 PrintBuffer(byteData, byteSize, tag);
563 }
564
HcStringUtilTest004()565 static void HcStringUtilTest004()
566 {
567 const char oriData[] = "abcd";
568 char anonymousData[TEST_MIN_ANONYMOUS_LEN + TEST_LEN_TWO] = { 0 };
569 (void)GetAnonymousString(oriData, nullptr, TEST_MIN_ANONYMOUS_LEN + 1);
570 (void)GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN - 1);
571 (void)GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN + 1);
572 (void)GetAnonymousString(oriData, anonymousData, TEST_MIN_ANONYMOUS_LEN + TEST_LEN_TWO);
573 }
574
ParseTlvHeadTest001()575 static void ParseTlvHeadTest001()
576 {
577 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
578 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
579 TlvBase tlvBase = {
580 .tag = 0,
581 .length = 0,
582 .checkTag = 1,
583 };
584 (void)ParseTlvHead(&tlvBase, nullptr);
585 (void)ParseTlvHead(&tlvBase, &parcelWithData);
586 parcelWithData.beginPos = PARCEL_UINT_MAX;
587 tlvBase.checkTag = tlvBase.length;
588 (void)ParseTlvHead(&tlvBase, &parcelWithData);
589 parcelWithData.beginPos = 0;
590 tlvBase.length = MAX_TLV_LENGTH + 1;
591 (void)ParseTlvHead(&tlvBase, &parcelWithData);
592 tlvBase.length = 0;
593 (void)ParseTlvHead(&tlvBase, &parcelWithData);
594 DeleteParcel(&parcelWithData);
595 }
596
597
ParseTlvNodeTest001()598 static void ParseTlvNodeTest001()
599 {
600 HcParcel parcelWithData = CreateParcel(TEST_BUFFER_SIZE, TEST_BUFFER_SIZE);
601 ParcelWriteUint32(&parcelWithData, TEST_SRC_DATA);
602 TlvBase tlvBase = {
603 .tag = 0,
604 .length = GetParcelDataSize(&parcelWithData) + 1,
605 .checkTag = 1,
606 };
607 (void)ParseTlvNode(nullptr, &parcelWithData, true);
608 (void)ParseTlvNode(&tlvBase, &parcelWithData, true);
609 DeleteParcel(&parcelWithData);
610 }
611
FuzzDoCallback(const uint8_t * data,size_t size)612 bool FuzzDoCallback(const uint8_t* data, size_t size)
613 {
614 (void)data;
615 (void)size;
616 HcParcelNullPtrTest001();
617 HcParcelNullPtrTest002();
618 HcParcelInValidDataSizeTest001();
619 HcParcelInValidDataSizeTest002();
620 HcParcelReadRevertTest001();
621 HcParcelCreateTest001();
622 HcParcelReadTest001();
623 HcParcelEraseBlockTest001();
624 HcParcelRevertTest001();
625 HcParcelReadWrite001();
626 HcParcelRealloc001();
627 HcParcelCopy001();
628 HcParcelReadWriteRevert001();
629 HcParcelPop001();
630 HcStringTest001();
631 HcCreateJsonTest001();
632 HcDeleteJsonTest001();
633 HcJsonGetTest001();
634 HcJsonGetTest002();
635 HcJsonGetTest003();
636 HcJsonGetTest004();
637 HcJsonAddTest001();
638 HcJsonAddTest002();
639 HcJsonAddTest003();
640 HcClearJsonTest001();
641 HcClearJsonTest002();
642 HcClearJsonTest003();
643 HcStringUtilTest001();
644 HcStringUtilTest002();
645 HcStringUtilTest003();
646 HcStringUtilTest004();
647 ParseTlvHeadTest001();
648 ParseTlvNodeTest001();
649 return true;
650 }
651 }
652 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)653 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
654 {
655 /* Run your code on data */
656 OHOS::FuzzDoCallback(data, size);
657 return 0;
658 }
659
660