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