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