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 <cstddef>
17 #include <cstdint>
18 #include <fuzzer/FuzzedDataProvider.h>
19 #include "meta/meta.h"
20 #include "common/native_mfmagic.h"
21 #include "native_cencinfo.h"
22
23 #define FUZZ_PROJECT_NAME "avcencinfo_fuzzer"
24
25 using namespace std;
26 using namespace OHOS::Media;
27
28 #define AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cond, ret) \
29 do { \
30 if (!(cond)) { \
31 return ret; \
32 } \
33 } while (0)
34
35 #define AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(cond, label) \
36 do { \
37 if (!(cond)) { \
38 goto label; \
39 } \
40 } while (0)
41
42 namespace OHOS {
43 namespace AvCencInfoFuzzer {
44
CencInfoCreateFuzzTest(const uint8_t * data,size_t size)45 bool CencInfoCreateFuzzTest(const uint8_t *data, size_t size)
46 {
47 (void)data;
48 (void)size;
49 OH_AVErrCode errNo = AV_ERR_OK;
50 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
51 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
52 errNo = OH_AVCencInfo_Destroy(cencInfo);
53 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
54 return true;
55 }
56
CencInfoDestroyFuzzTest(const uint8_t * data,size_t size)57 bool CencInfoDestroyFuzzTest(const uint8_t *data, size_t size)
58 {
59 (void)data;
60 (void)size;
61 OH_AVErrCode errNo = AV_ERR_OK;
62 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
63 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
64 errNo = OH_AVCencInfo_Destroy(cencInfo);
65 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
66 return true;
67 }
68
CencInfoSetAlgorithm(void)69 bool CencInfoSetAlgorithm(void)
70 {
71 OH_AVErrCode errNo = AV_ERR_OK;
72 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
73 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
74
75 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_UNENCRYPTED);
76 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
77
78 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CTR);
79 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
80
81 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_WV);
82 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
83
84 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CBC);
85 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
86
87 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_SM4_CBC);
88 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
89
90 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_SM4_CTR);
91 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
92
93 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, static_cast<enum DrmCencAlgorithm>(DRM_ALG_CENC_SM4_CTR + 1));
94 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
95 _EXIT:
96 errNo = OH_AVCencInfo_Destroy(cencInfo);
97 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
98 return true;
99 }
100
CencInfoSetAlgorithmFuzzTest(const uint8_t * data,size_t size)101 bool CencInfoSetAlgorithmFuzzTest(const uint8_t *data, size_t size)
102 {
103 (void)size;
104 OH_AVErrCode errNo = AV_ERR_OK;
105 DrmCencAlgorithm algo = static_cast<enum DrmCencAlgorithm>(*data);
106 static uint8_t cencInfoSetAlgorithmFuzzTestFlag = 0;
107 if (cencInfoSetAlgorithmFuzzTestFlag == 0) {
108 CencInfoSetAlgorithm();
109 cencInfoSetAlgorithmFuzzTestFlag = 1;
110 }
111 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
112 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
113
114 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, algo);
115 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
116 _EXIT:
117 errNo = OH_AVCencInfo_Destroy(cencInfo);
118 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
119 return true;
120 }
121
CencInfoSetKeyIdAndIv(void)122 bool CencInfoSetKeyIdAndIv(void)
123 {
124 OH_AVErrCode errNo = AV_ERR_OK;
125 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
126 uint8_t keyId[] = {
127 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
128 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
129 uint32_t ivLen = DRM_KEY_IV_SIZE;
130 uint8_t iv[] = {
131 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
132 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
133
134 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
135 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
136 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
137 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
138 _EXIT:
139 errNo = OH_AVCencInfo_Destroy(cencInfo);
140 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
141 return true;
142 }
143
CencInfoSetKeyIdAndIvFuzzTest(const uint8_t * data,size_t size)144 bool CencInfoSetKeyIdAndIvFuzzTest(const uint8_t *data, size_t size)
145 {
146 OH_AVErrCode errNo = AV_ERR_OK;
147 static uint8_t cencInfoSetKeyIdAndIvFuzzTestFlag = 0;
148 if (cencInfoSetKeyIdAndIvFuzzTestFlag == 0) {
149 CencInfoSetKeyIdAndIv();
150 cencInfoSetKeyIdAndIvFuzzTestFlag = 1;
151 }
152 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
153 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
154
155 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, const_cast<uint8_t *>(data), static_cast<uint32_t>(size),
156 const_cast<uint8_t *>(data), static_cast<uint32_t>(size));
157 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
158 _EXIT:
159 errNo = OH_AVCencInfo_Destroy(cencInfo);
160 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
161 return true;
162 }
163
CencInfoSetSubsampleInfo(void)164 bool CencInfoSetSubsampleInfo(void)
165 {
166 OH_AVErrCode errNo = AV_ERR_OK;
167 uint32_t encryptedBlockCount = 0;
168 uint32_t skippedBlockCount = 0;
169 uint32_t firstEncryptedOffset = 0;
170 uint32_t subsampleCount = 1;
171 DrmSubsample subsamples[1] = { {0x10, 0x16} };
172
173 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
174 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
175 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
176 subsampleCount, subsamples);
177 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
178 _EXIT:
179 errNo = OH_AVCencInfo_Destroy(cencInfo);
180 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
181 return true;
182 }
183
CencInfoSetSubsampleInfoFuzzTest(const uint8_t * data,size_t size)184 bool CencInfoSetSubsampleInfoFuzzTest(const uint8_t *data, size_t size)
185 {
186 OH_AVErrCode errNo = AV_ERR_OK;
187 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(size >= 6, false); // 6:sample info size
188 uint32_t encryptedBlockCount = static_cast<uint32_t>(data[0]);
189 uint32_t skippedBlockCount = static_cast<uint32_t>(data[1]); // 1:skipped block count index
190 uint32_t firstEncryptedOffset = static_cast<uint32_t>(data[2]); // 2:first encrypted offset index
191 uint32_t subsampleCount = static_cast<uint32_t>(data[3]); // 3:subsample count index
192 DrmSubsample subsamples[DRM_KEY_MAX_SUB_SAMPLE_NUM];
193 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(subsampleCount <= DRM_KEY_MAX_SUB_SAMPLE_NUM, false);
194 FuzzedDataProvider fdp(data, size);
195 for (uint32_t i = 0; i < subsampleCount; i++) {
196 subsamples[i].clearHeaderLen = fdp.ConsumeIntegral<uint32_t>();
197 subsamples[i].payLoadLen = fdp.ConsumeIntegral<uint32_t>();
198 }
199 static uint8_t cencInfoSetSubsampleInfoFuzzTestFlag = 0;
200 if (cencInfoSetSubsampleInfoFuzzTestFlag == 0) {
201 CencInfoSetSubsampleInfo();
202 cencInfoSetSubsampleInfoFuzzTestFlag = 1;
203 }
204 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
205 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
206
207 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
208 subsampleCount, subsamples);
209 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
210 _EXIT:
211 errNo = OH_AVCencInfo_Destroy(cencInfo);
212 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
213 return true;
214 }
215
CencInfoSetMode(void)216 bool CencInfoSetMode(void)
217 {
218 OH_AVErrCode errNo = AV_ERR_OK;
219
220 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
221 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
222
223 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
224 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
225
226 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET);
227 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
228
229 errNo = OH_AVCencInfo_SetMode(cencInfo,
230 static_cast<enum DrmCencInfoMode>(DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET + 1));
231 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
232 _EXIT:
233 errNo = OH_AVCencInfo_Destroy(cencInfo);
234 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
235 return true;
236 }
237
CencInfoSetModeFuzzTest(const uint8_t * data,size_t size)238 bool CencInfoSetModeFuzzTest(const uint8_t *data, size_t size)
239 {
240 (void)size;
241 OH_AVErrCode errNo = AV_ERR_OK;
242 DrmCencInfoMode mode = static_cast<enum DrmCencInfoMode>(*data);
243 static uint8_t cencInfoSetModeFuzzTestFlag = 0;
244 if (cencInfoSetModeFuzzTestFlag == 0) {
245 CencInfoSetMode();
246 cencInfoSetModeFuzzTestFlag = 1;
247 }
248 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
249 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(cencInfo != nullptr, false);
250
251 errNo = OH_AVCencInfo_SetMode(cencInfo, mode);
252 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
253 _EXIT:
254 errNo = OH_AVCencInfo_Destroy(cencInfo);
255 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(errNo == AV_ERR_OK, false);
256 return true;
257 }
258
CencInfoSetAVBuffer(void)259 bool CencInfoSetAVBuffer(void)
260 {
261 uint32_t keyIdLen = DRM_KEY_ID_SIZE;
262 uint8_t keyId[] = {
263 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
264 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
265 uint32_t ivLen = DRM_KEY_IV_SIZE;
266 uint8_t iv[] = {
267 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
268 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
269 uint32_t encryptedBlockCount = 0;
270 uint32_t skippedBlockCount = 0;
271 uint32_t firstEncryptedOffset = 0;
272 uint32_t subsampleCount = 1;
273 DrmSubsample subsamples[1] = { {0x10, 0x16} };
274 OH_AVErrCode errNo = AV_ERR_OK;
275 MemoryFlag memFlag = MEMORY_READ_WRITE;
276
277 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
278 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
279
280 std::shared_ptr<AVBuffer> inBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(DRM_KEY_ID_SIZE));
281 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf != nullptr, false);
282 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf->memory_ != nullptr, false);
283 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf->memory_->GetCapacity() == DRM_KEY_ID_SIZE, false);
284
285 struct OH_AVBuffer *buffer = new (std::nothrow) OH_AVBuffer(inBuf);
286 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(buffer != nullptr, false);
287
288 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
289 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(cencInfo != nullptr, _EXIT1);
290
291 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, DRM_ALG_CENC_AES_CTR);
292 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
293
294 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, keyId, keyIdLen, iv, ivLen);
295 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
296
297 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
298 subsampleCount, subsamples);
299 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
300
301 errNo = OH_AVCencInfo_SetMode(cencInfo, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET);
302 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
303
304 errNo = OH_AVCencInfo_SetAVBuffer(cencInfo, buffer);
305 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
306 _EXIT:
307 (void)OH_AVCencInfo_Destroy(cencInfo);
308 _EXIT1:
309 delete buffer;
310 return true;
311 }
312
CencInfoSetAVBufferFuzzTest(const uint8_t * data,size_t size)313 bool CencInfoSetAVBufferFuzzTest(const uint8_t *data, size_t size)
314 {
315 OH_AVErrCode errNo = AV_ERR_OK;
316 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(size >= 8, false); // 8:cenc info size
317 DrmCencAlgorithm algo = static_cast<enum DrmCencAlgorithm>(data[0]);
318 DrmCencInfoMode mode = static_cast<enum DrmCencInfoMode>(data[1]); // 1:mode index
319 uint32_t encryptedBlockCount = static_cast<uint32_t>(data[2]); // 2:encrypted block count index
320 uint32_t skippedBlockCount = static_cast<uint32_t>(data[3]); // 3:skipped block count index
321 uint32_t firstEncryptedOffset = static_cast<uint32_t>(data[4]); // 4:first encrypted offset index
322 uint32_t subsampleCount = static_cast<uint32_t>(data[5]); // 5:subsample count index
323 DrmSubsample subsamples[DRM_KEY_MAX_SUB_SAMPLE_NUM];
324 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(subsampleCount <= DRM_KEY_MAX_SUB_SAMPLE_NUM, false);
325 FuzzedDataProvider fdp(data, size);
326 for (uint32_t i = 0; i < subsampleCount; i++) {
327 subsamples[i].clearHeaderLen = fdp.ConsumeIntegral<uint32_t>();
328 subsamples[i].payLoadLen = fdp.ConsumeIntegral<uint32_t>();
329 }
330 static uint8_t cencInfoSetAVBufferFuzzTestFlag = 0;
331 if (cencInfoSetAVBufferFuzzTestFlag == 0) {
332 CencInfoSetAVBuffer();
333 cencInfoSetAVBufferFuzzTestFlag = 1;
334 }
335
336 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(MEMORY_READ_WRITE);
337 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
338
339 std::shared_ptr<AVBuffer> inBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(DRM_KEY_ID_SIZE));
340 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf != nullptr, false);
341 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf->memory_ != nullptr, false);
342 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(inBuf->memory_->GetCapacity() == DRM_KEY_ID_SIZE, false);
343
344 struct OH_AVBuffer *buffer = new (std::nothrow) OH_AVBuffer(inBuf);
345 AV_CENC_INFO_FUZZ_CHECK_AND_RETURN_RET(buffer != nullptr, false);
346
347 OH_AVCencInfo *cencInfo = OH_AVCencInfo_Create();
348 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(cencInfo != nullptr, _EXIT1);
349
350 errNo = OH_AVCencInfo_SetAlgorithm(cencInfo, algo);
351 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
352
353 errNo = OH_AVCencInfo_SetKeyIdAndIv(cencInfo, const_cast<uint8_t *>(data), static_cast<uint32_t>(size),
354 const_cast<uint8_t *>(data), static_cast<uint32_t>(size));
355 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
356
357 errNo = OH_AVCencInfo_SetSubsampleInfo(cencInfo, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset,
358 subsampleCount, subsamples);
359 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
360
361 errNo = OH_AVCencInfo_SetMode(cencInfo, mode);
362 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
363
364 errNo = OH_AVCencInfo_SetAVBuffer(cencInfo, buffer);
365 AV_CENC_INFO_FUZZ_CHECK_AND_GOTO(errNo == AV_ERR_OK, _EXIT);
366 _EXIT:
367 (void)OH_AVCencInfo_Destroy(cencInfo);
368 _EXIT1:
369 delete buffer;
370 return true;
371 }
372
373 } // namespace AvCencInfoFuzzer
374 } // namespace OHOS
375
376 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)377 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
378 {
379 /* Run your code on data */
380 if (data == nullptr) {
381 return 0;
382 }
383 if (size < sizeof(int64_t)) {
384 return 0;
385 }
386 OHOS::AvCencInfoFuzzer::CencInfoCreateFuzzTest(data, size);
387 OHOS::AvCencInfoFuzzer::CencInfoDestroyFuzzTest(data, size);
388 OHOS::AvCencInfoFuzzer::CencInfoSetAlgorithmFuzzTest(data, size);
389 OHOS::AvCencInfoFuzzer::CencInfoSetKeyIdAndIvFuzzTest(data, size);
390 OHOS::AvCencInfoFuzzer::CencInfoSetSubsampleInfoFuzzTest(data, size);
391 OHOS::AvCencInfoFuzzer::CencInfoSetModeFuzzTest(data, size);
392 OHOS::AvCencInfoFuzzer::CencInfoSetAVBufferFuzzTest(data, size);
393 return 0;
394 }
395