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 "codec_drm_decrypt.h"
20 #include "securec.h"
21 #ifdef SUPPORT_DRM
22 #include "imedia_key_session_service.h"
23 #endif
24
25 #define FUZZ_PROJECT_NAME "drmdecryptor_fuzzer"
26
27 using namespace std;
28 using namespace OHOS::MediaAVCodec;
29 using namespace OHOS::Media;
30
31 const uint8_t *fuzzData = nullptr;
32 size_t fuzzSize = 0;
33
34 #define DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(cond, ret) \
35 do { \
36 if (!(cond)) { \
37 return ret; \
38 } \
39 } while (0)
40
41 namespace {
42 const uint32_t KEY_ID_LEN = 16;
43 const uint32_t IV_LEN = 16;
44
45 // for H264
46 const uint8_t DRM_H264_KEY_ID[] = {
47 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53,
48 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x37};
49 const uint8_t DRM_H264_IV[] = {
50 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53,
51 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x37};
52 uint32_t DRM_H264_ENCRYPTED_BUFFER_SIZE = 418;
53 const uint8_t DRM_H264_SM4C_ENCRYPTED_BUFFER[] = {
54 0x00, 0x00, 0x00, 0x01, 0x09, 0x10, 0x00, 0x00, 0x00, 0x01, 0x67, 0x64, 0x00, 0x1f, 0xac, 0xd3,
55 0x01, 0xe0, 0x08, 0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03, 0x03,
56 0xce, 0x64, 0x00, 0x01, 0x31, 0x2d, 0x00, 0x00, 0x2f, 0xaf, 0x0a, 0x27, 0x28, 0x07, 0x8c, 0x18,
57 0x9c, 0x00, 0x00, 0x00, 0x01, 0x68, 0xea, 0xac, 0xb2, 0x2c, 0x00, 0x00, 0x01, 0x06, 0x00, 0x05,
58 0x98, 0xb8, 0x00, 0xaf, 0xd4, 0x80, 0x00, 0x00, 0x01, 0x06, 0x05, 0x26, 0xdc, 0x45, 0xe9, 0xbd,
59 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x73, 0x75, 0x6d, 0x61,
60 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2c, 0x76, 0x32, 0x30, 0x31, 0x36, 0x20, 0x2d, 0x31, 0x34,
61 0x38, 0x00, 0x80, 0x00, 0x00, 0x01, 0x06, 0x01, 0x02, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x01, 0x06,
62 0x05, 0xc8, 0x70, 0xc1, 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69,
63 0x4b, 0x66, 0xf0, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
64 0x5f, 0x30, 0x37, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
65 0x5f, 0x30, 0x37, 0x10, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49,
66 0x44, 0x5f, 0x30, 0x37, 0xc0, 0x84, 0x43, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73,
67 0x68, 0x00, 0x00, 0x03, 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43,
68 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72,
69 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f,
70 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x43,
71 0x31, 0x7a, 0x62, 0x54, 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c,
72 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68,
73 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74,
74 0x73, 0x22, 0x3a, 0x22, 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x34, 0x22, 0x7d, 0x80, 0x00, 0x00,
75 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0xff, 0x9f, 0x97, 0x12, 0x77, 0x06, 0xff, 0x81, 0x48, 0xf0,
76 0x84, 0xc3, 0xfb, 0x35, 0x95, 0x4d, 0x40, 0x94, 0x6e, 0x1a, 0xd3, 0x6f, 0xb0, 0xc3, 0xae, 0x35,
77 0x01, 0x6f, 0x46, 0x26, 0xae, 0x2b, 0x46, 0x6b, 0x81, 0x9f, 0xc1, 0xf9, 0x46, 0x86, 0x5b, 0x62,
78 0xaa, 0x0d, 0x2a, 0x39, 0xc0, 0xae, 0x2d, 0x52, 0xef, 0x97, 0x6e, 0xd5, 0x78, 0xec, 0xa4, 0x25,
79 0xee, 0xa7, 0xa6, 0xae, 0xed, 0xf3, 0xe7, 0xdf, 0xef, 0xd8, 0x84, 0xb4, 0x45, 0xd4, 0xfb, 0x67,
80 0x8c, 0x6c}; //418
81 const uint8_t DRM_H264_SM4S_ENCRYPTED_BUFFER[] = {
82 0x00, 0x00, 0x00, 0x01, 0x09, 0x10, 0x00, 0x00, 0x00, 0x01, 0x67, 0x64, 0x00, 0x1f, 0xac, 0xd3,
83 0x01, 0xe0, 0x08, 0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03, 0x03,
84 0xce, 0x64, 0x00, 0x01, 0x31, 0x2d, 0x00, 0x00, 0x2f, 0xaf, 0x0a, 0x27, 0x28, 0x07, 0x8c, 0x18,
85 0x9c, 0x00, 0x00, 0x00, 0x01, 0x68, 0xea, 0xac, 0xb2, 0x2c, 0x00, 0x00, 0x01, 0x06, 0x00, 0x05,
86 0x98, 0xb8, 0x00, 0xaf, 0xd4, 0x80, 0x00, 0x00, 0x01, 0x06, 0x05, 0x26, 0xdc, 0x45, 0xe9, 0xbd,
87 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x73, 0x75, 0x6d, 0x61,
88 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2c, 0x76, 0x32, 0x30, 0x31, 0x36, 0x20, 0x2d, 0x31, 0x34,
89 0x38, 0x00, 0x80, 0x00, 0x00, 0x01, 0x06, 0x01, 0x02, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x01, 0x06,
90 0x05, 0xc8, 0x70, 0xc1, 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69,
91 0x4b, 0x66, 0xf0, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
92 0x5f, 0x30, 0x37, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
93 0x5f, 0x30, 0x37, 0x10, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49,
94 0x44, 0x5f, 0x30, 0x37, 0xc0, 0x84, 0x41, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73,
95 0x68, 0x00, 0x00, 0x03, 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43,
96 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72,
97 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f,
98 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x43,
99 0x31, 0x7a, 0x62, 0x54, 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c,
100 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68,
101 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74,
102 0x73, 0x22, 0x3a, 0x22, 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x34, 0x22, 0x7d, 0x80, 0x00, 0x00,
103 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0xff, 0x9f, 0x97, 0x12, 0x77, 0x06, 0xff, 0x81, 0x48, 0xf0,
104 0x84, 0xc3, 0xfb, 0x35, 0x95, 0x4d, 0x40, 0x94, 0x6e, 0x1a, 0xd3, 0x6f, 0xb0, 0xc3, 0xae, 0x35,
105 0x01, 0x6f, 0x46, 0x26, 0xae, 0x2b, 0x46, 0x6b, 0x81, 0x9f, 0xc1, 0xf9, 0x46, 0x86, 0x5b, 0x62,
106 0xaa, 0x0d, 0x2a, 0x39, 0xc0, 0xae, 0x2d, 0x52, 0xef, 0x97, 0x6e, 0xd5, 0x78, 0xec, 0xa4, 0x25,
107 0xee, 0xa7, 0xa6, 0xae, 0xed, 0xf3, 0xe7, 0xdf, 0xef, 0xd8, 0x84, 0xb4, 0x45, 0xd4, 0xfb, 0x67,
108 0x8c, 0x6c}; //418
109 const uint8_t DRM_H264_CBC1_ENCRYPTED_BUFFER[] = {
110 0x00, 0x00, 0x00, 0x01, 0x09, 0x10, 0x00, 0x00, 0x00, 0x01, 0x67, 0x64, 0x00, 0x1f, 0xac, 0xd3,
111 0x01, 0xe0, 0x08, 0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03, 0x03,
112 0xce, 0x64, 0x00, 0x01, 0x31, 0x2d, 0x00, 0x00, 0x2f, 0xaf, 0x0a, 0x27, 0x28, 0x07, 0x8c, 0x18,
113 0x9c, 0x00, 0x00, 0x00, 0x01, 0x68, 0xea, 0xac, 0xb2, 0x2c, 0x00, 0x00, 0x01, 0x06, 0x00, 0x05,
114 0x98, 0xb8, 0x00, 0xaf, 0xd4, 0x80, 0x00, 0x00, 0x01, 0x06, 0x05, 0x26, 0xdc, 0x45, 0xe9, 0xbd,
115 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x73, 0x75, 0x6d, 0x61,
116 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2c, 0x76, 0x32, 0x30, 0x31, 0x36, 0x20, 0x2d, 0x31, 0x34,
117 0x38, 0x00, 0x80, 0x00, 0x00, 0x01, 0x06, 0x01, 0x02, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x01, 0x06,
118 0x05, 0xc8, 0x70, 0xc1, 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69,
119 0x4b, 0x66, 0xf0, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
120 0x5f, 0x30, 0x37, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
121 0x5f, 0x30, 0x37, 0x10, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49,
122 0x44, 0x5f, 0x30, 0x37, 0xc0, 0x84, 0x45, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73,
123 0x68, 0x00, 0x00, 0x03, 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43,
124 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72,
125 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f,
126 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x43,
127 0x31, 0x7a, 0x62, 0x54, 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c,
128 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68,
129 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74,
130 0x73, 0x22, 0x3a, 0x22, 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x34, 0x22, 0x7d, 0x80, 0x00, 0x00,
131 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0xff, 0x9f, 0x97, 0x12, 0x77, 0x06, 0xff, 0x81, 0x48, 0xf0,
132 0x84, 0xc3, 0xfb, 0x35, 0x95, 0x4d, 0x40, 0x94, 0x6e, 0x1a, 0xd3, 0x6f, 0xb0, 0xc3, 0xae, 0x35,
133 0x01, 0x6f, 0x46, 0x26, 0xae, 0x2b, 0x46, 0x6b, 0x81, 0x9f, 0xc1, 0xf9, 0x46, 0x86, 0x5b, 0x62,
134 0xaa, 0x0d, 0x2a, 0x39, 0xc0, 0xae, 0x2d, 0x52, 0xef, 0x97, 0x6e, 0xd5, 0x78, 0xec, 0xa4, 0x25,
135 0xee, 0xa7, 0xa6, 0xae, 0xed, 0xf3, 0xe7, 0xdf, 0xef, 0xd8, 0x84, 0xb4, 0x45, 0xd4, 0xfb, 0x67,
136 0x8c, 0x6c}; //418
137 const uint8_t DRM_H264_CBCS_ENCRYPTED_BUFFER[] = {
138 0x00, 0x00, 0x00, 0x01, 0x09, 0x10, 0x00, 0x00, 0x00, 0x01, 0x67, 0x64, 0x00, 0x1f, 0xac, 0xd3,
139 0x01, 0xe0, 0x08, 0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03, 0x03,
140 0xce, 0x64, 0x00, 0x01, 0x31, 0x2d, 0x00, 0x00, 0x2f, 0xaf, 0x0a, 0x27, 0x28, 0x07, 0x8c, 0x18,
141 0x9c, 0x00, 0x00, 0x00, 0x01, 0x68, 0xea, 0xac, 0xb2, 0x2c, 0x00, 0x00, 0x01, 0x06, 0x00, 0x05,
142 0x98, 0xb8, 0x00, 0xaf, 0xd4, 0x80, 0x00, 0x00, 0x01, 0x06, 0x05, 0x26, 0xdc, 0x45, 0xe9, 0xbd,
143 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x73, 0x75, 0x6d, 0x61,
144 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2c, 0x76, 0x32, 0x30, 0x31, 0x36, 0x20, 0x2d, 0x31, 0x34,
145 0x38, 0x00, 0x80, 0x00, 0x00, 0x01, 0x06, 0x01, 0x02, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x01, 0x06,
146 0x05, 0xc8, 0x70, 0xc1, 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69,
147 0x4b, 0x66, 0xf0, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
148 0x5f, 0x30, 0x37, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
149 0x5f, 0x30, 0x37, 0x10, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49,
150 0x44, 0x5f, 0x30, 0x37, 0xc0, 0x84, 0x42, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73,
151 0x68, 0x00, 0x00, 0x03, 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43,
152 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72,
153 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f,
154 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x43,
155 0x31, 0x7a, 0x62, 0x54, 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c,
156 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68,
157 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74,
158 0x73, 0x22, 0x3a, 0x22, 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x34, 0x22, 0x7d, 0x80, 0x00, 0x00,
159 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0xff, 0x9f, 0x97, 0x12, 0x77, 0x06, 0xff, 0x81, 0x48, 0xf0,
160 0x84, 0xc3, 0xfb, 0x35, 0x95, 0x4d, 0x40, 0x94, 0x6e, 0x1a, 0xd3, 0x6f, 0xb0, 0xc3, 0xae, 0x35,
161 0x01, 0x6f, 0x46, 0x26, 0xae, 0x2b, 0x46, 0x6b, 0x81, 0x9f, 0xc1, 0xf9, 0x46, 0x86, 0x5b, 0x62,
162 0xaa, 0x0d, 0x2a, 0x39, 0xc0, 0xae, 0x2d, 0x52, 0xef, 0x97, 0x6e, 0xd5, 0x78, 0xec, 0xa4, 0x25,
163 0xee, 0xa7, 0xa6, 0xae, 0xed, 0xf3, 0xe7, 0xdf, 0xef, 0xd8, 0x84, 0xb4, 0x45, 0xd4, 0xfb, 0x67,
164 0x8c, 0x6c}; //418
165 const uint8_t DRM_H264_NONE_ENCRYPTED_BUFFER[] = {
166 0x00, 0x00, 0x00, 0x01, 0x09, 0x10, 0x00, 0x00, 0x00, 0x01, 0x67, 0x64, 0x00, 0x1f, 0xac, 0xd3,
167 0x01, 0xe0, 0x08, 0x9f, 0x97, 0x01, 0x10, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x03, 0x03,
168 0xce, 0x64, 0x00, 0x01, 0x31, 0x2d, 0x00, 0x00, 0x2f, 0xaf, 0x0a, 0x27, 0x28, 0x07, 0x8c, 0x18,
169 0x9c, 0x00, 0x00, 0x00, 0x01, 0x68, 0xea, 0xac, 0xb2, 0x2c, 0x00, 0x00, 0x01, 0x06, 0x00, 0x05,
170 0x98, 0xb8, 0x00, 0xaf, 0xd4, 0x80, 0x00, 0x00, 0x01, 0x06, 0x05, 0x26, 0xdc, 0x45, 0xe9, 0xbd,
171 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x73, 0x75, 0x6d, 0x61,
172 0x20, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2c, 0x76, 0x32, 0x30, 0x31, 0x36, 0x20, 0x2d, 0x31, 0x34,
173 0x38, 0x00, 0x80, 0x00, 0x00, 0x01, 0x06, 0x01, 0x02, 0x00, 0x0a, 0x80, 0x00, 0x00, 0x01, 0x06,
174 0x05, 0xc8, 0x70, 0xc1, 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69,
175 0x4b, 0x66, 0xf0, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
176 0x5f, 0x30, 0x37, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44,
177 0x5f, 0x30, 0x37, 0x10, 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49,
178 0x44, 0x5f, 0x30, 0x37, 0xc0, 0x84, 0x40, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73,
179 0x68, 0x00, 0x00, 0x03, 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43,
180 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72,
181 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f,
182 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x43,
183 0x31, 0x7a, 0x62, 0x54, 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c,
184 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68,
185 0x65, 0x6d, 0x61, 0x22, 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74,
186 0x73, 0x22, 0x3a, 0x22, 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x34, 0x22, 0x7d, 0x80, 0x00, 0x00,
187 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0xff, 0x9f, 0x97, 0x12, 0x77, 0x06, 0xff, 0x81, 0x48, 0xf0,
188 0x84, 0xc3, 0xfb, 0x35, 0x95, 0x4d, 0x40, 0x94, 0x6e, 0x1a, 0xd3, 0x6f, 0xb0, 0xc3, 0xae, 0x35,
189 0x01, 0x6f, 0x46, 0x26, 0xae, 0x2b, 0x46, 0x6b, 0x81, 0x9f, 0xc1, 0xf9, 0x46, 0x86, 0x5b, 0x62,
190 0xaa, 0x0d, 0x2a, 0x39, 0xc0, 0xae, 0x2d, 0x52, 0xef, 0x97, 0x6e, 0xd5, 0x78, 0xec, 0xa4, 0x25,
191 0xee, 0xa7, 0xa6, 0xae, 0xed, 0xf3, 0xe7, 0xdf, 0xef, 0xd8, 0x84, 0xb4, 0x45, 0xd4, 0xfb, 0x67,
192 0x8c, 0x6c}; //418
193
194 // for HEVC
195 const uint8_t DRM_HEVC_SM4C_KEY_ID[] = {
196 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53,
197 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x32};
198 const uint8_t DRM_HEVC_SM4C_IV[] = {
199 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53,
200 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x32};
201 uint32_t DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE = 351;
202 #ifdef SUPPORT_DRM
203 const uint8_t DRM_HEVC_SM4C_ENCRYPTED_BUFFER[] = {
204 0x00, 0x00, 0x00, 0x01, 0x46, 0x01, 0x50, 0x00, 0x00, 0x01, 0x4e, 0x01, 0x05, 0xc8, 0x70, 0xc1,
205 0xdb, 0x9f, 0x66, 0xae, 0x41, 0x27, 0xbf, 0xc0, 0xbb, 0x19, 0x81, 0x69, 0x4b, 0x66, 0xf0, 0x55,
206 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x32, 0x55,
207 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x32, 0x10,
208 0x55, 0x44, 0x52, 0x4d, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x5f, 0x43, 0x49, 0x44, 0x5f, 0x30, 0x32,
209 0xc0, 0x84, 0x33, 0x00, 0x00, 0x03, 0x00, 0x00, 0x82, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x03,
210 0x00, 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, 0x43, 0xdd, 0x3c, 0x6e, 0x72,
211 0xc4, 0x2c, 0x00, 0x00, 0x03, 0x00, 0x62, 0x7b, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
212 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
213 0x74, 0x49, 0x44, 0x22, 0x3a, 0x22, 0x61, 0x44, 0x49, 0x32, 0x4e, 0x53, 0x31, 0x7a, 0x62, 0x54,
214 0x52, 0x6a, 0x4c, 0x58, 0x52, 0x7a, 0x4c, 0x54, 0x41, 0x3d, 0x22, 0x2c, 0x22, 0x6b, 0x69, 0x64,
215 0x73, 0x22, 0x3a, 0x5b, 0x5d, 0x2c, 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22,
216 0x3a, 0x22, 0x73, 0x6d, 0x34, 0x63, 0x22, 0x2c, 0x22, 0x65, 0x78, 0x74, 0x73, 0x22, 0x3a, 0x22,
217 0x74, 0x73, 0x2f, 0x68, 0x32, 0x36, 0x35, 0x22, 0x7d, 0x80, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,
218 0xe0, 0x24, 0xbe, 0x08, 0x32, 0x96, 0x00, 0x00, 0x03, 0x02, 0x85, 0xda, 0x3c, 0xd7, 0x82, 0x78,
219 0x1e, 0xb7, 0x2e, 0xad, 0x4c, 0x59, 0xb2, 0x2b, 0x72, 0x1f, 0xbe, 0xff, 0x1e, 0xbe, 0xf3, 0x1d,
220 0xab, 0x9c, 0x2a, 0x50, 0xfd, 0xdd, 0x3c, 0x00, 0xe9, 0xd6, 0xa3, 0x04, 0x0a, 0x7e, 0x9a, 0x02,
221 0x7f, 0x3e, 0x3c, 0x00, 0x2c, 0xf7, 0x86, 0xe4, 0x03, 0x5b, 0x6d, 0xe5, 0xfe, 0x5c, 0xe7, 0x88,
222 0x6d, 0x44, 0x67, 0x16, 0x38, 0x95, 0x02, 0x3a, 0x34, 0x31, 0x63, 0x0e, 0x9c, 0xe0, 0xe3, 0x70,
223 0xcb, 0xc3, 0x4c, 0x5d, 0x21, 0xaa, 0x9e, 0x0d, 0x45, 0x38, 0x56, 0xb9, 0xc9, 0x2b, 0xf7, 0xf5,
224 0xe1, 0xd9, 0x13, 0xa0, 0x46, 0xc3, 0xe8, 0x16, 0xe0, 0x78, 0x75, 0xe8, 0x69, 0x5d, 0xc1, 0xe3,
225 0x1d, 0xaa, 0x8c, 0xf4, 0x59, 0x75, 0xc2, 0xe1, 0x36, 0x98, 0x4f, 0x83, 0x2e, 0x87, 0x51}; // 351
226 #endif
227
228 // for AVS
229 const uint8_t DRM_AVS_SM4C_KEY_ID[] = {
230 0xd4, 0xb2, 0x01, 0xe4, 0x61, 0xc8, 0x98, 0x96,
231 0xcf, 0x05, 0x22, 0x39, 0x8d, 0x09, 0xe6, 0x28 };
232 const uint8_t DRM_AVS_SM4C_IV[] = {
233 0xbf, 0x77, 0xed, 0x51, 0x81, 0xde, 0x36, 0x3e,
234 0x52, 0xf7, 0x20, 0x4f, 0x72, 0x14, 0xa3, 0x95};
235 uint32_t DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE = 238;
236 #ifdef SUPPORT_DRM
237 const uint8_t DRM_AVS_SM4C_ENCRYPTED_BUFFER[] = {
238 0x00, 0x00, 0x01, 0xB5, 0xDF, 0x80, 0xD4, 0xB2, 0x01, 0xE4, 0x61, 0xC8, 0x98, 0x96, 0xCF, 0x05,
239 0x22, 0x39, 0x8D, 0x09, 0xE6, 0x28, 0x10, 0xBF, 0x77, 0xED, 0x51, 0x81, 0xDE, 0x36, 0x3E, 0x52,
240 0xF7, 0x20, 0x4F, 0x72, 0x14, 0xA3, 0x95, 0x00, 0x00, 0x01, 0xb6, 0xff, 0xff, 0xff, 0xff, 0xce,
241 0x14, 0x92, 0x10, 0x20, 0x82, 0xb5, 0xc0, 0x5e, 0x7b, 0xb4, 0x5a, 0x00, 0x00, 0x01, 0x00, 0xf6,
242 0x41, 0x55, 0xf7, 0x4f, 0xbb, 0x05, 0x15, 0xec, 0x11, 0xba, 0x98, 0x92, 0xdc, 0x21, 0x72, 0x75,
243 0x52, 0xfd, 0x9b, 0xff, 0x6c, 0x13, 0x75, 0x32, 0x11, 0x9a, 0x1c, 0xd4, 0xac, 0x58, 0x2c, 0x9a,
244 0x27, 0x4a, 0xab, 0x5c, 0x5b, 0x5e, 0xe1, 0xe8, 0xb9, 0x80, 0x9b, 0x0c, 0x63, 0xd8, 0xd1, 0xd8,
245 0xee, 0x8f, 0xce, 0x56, 0x14, 0xb2, 0xad, 0x30, 0x56, 0x7a, 0x22, 0x72, 0x85, 0x21, 0x1e, 0x47,
246 0x75, 0xd1, 0x30, 0xb1, 0x74, 0x5c, 0x0d, 0x75, 0xc4, 0x33, 0xcb, 0xfa, 0x14, 0x2d, 0x36, 0x32,
247 0x30, 0xd2, 0x2e, 0x9b, 0xc7, 0xd1, 0x5d, 0x3e, 0xd5, 0xaf, 0xed, 0x52, 0xbb, 0xa3, 0x73, 0xe7,
248 0x32, 0xfa, 0x4c, 0x5b, 0x4e, 0x73, 0xbd, 0x75, 0x94, 0x4a, 0x12, 0xfd, 0x73, 0x58, 0x95, 0x0c,
249 0x50, 0x6b, 0x91, 0xd7, 0x60, 0x52, 0xed, 0xb4, 0x33, 0xea, 0xee, 0x48, 0xbe, 0xde, 0x22, 0xe4,
250 0xa6, 0x48, 0xb8, 0xd5, 0xf7, 0x90, 0x1b, 0x2e, 0xbe, 0x69, 0xad, 0x86, 0xe9, 0x88, 0x23, 0x70,
251 0x31, 0x61, 0x5d, 0xe7, 0x60, 0x75, 0x27, 0x29, 0x5e, 0xf5, 0xe5, 0x86, 0x76, 0xb8, 0x42, 0x63,
252 0x42, 0x84, 0xbb, 0xb4, 0x48, 0x6c, 0x39, 0xc0, 0x40, 0x80, 0x00, 0x00, 0x01, 0x8f}; // 238
253 #endif
254
255 // for Audio
256 const uint8_t DRM_AUDIO_KEY_ID[] = {
257 0xf3, 0xc5, 0xe0, 0x36, 0x1e, 0x66, 0x54, 0xb2,
258 0x8f, 0x80, 0x49, 0xc7, 0x78, 0xb2, 0x39, 0x46};
259 const uint8_t DRM_AUDIO_IV[] = {
260 0xa4, 0x63, 0x1a, 0x15, 0x3a, 0x44, 0x3d, 0xf9,
261 0xee, 0xd0, 0x59, 0x30, 0x43, 0xdb, 0x75, 0x19};
262 uint32_t DRM_AUDIO_ENCRYPTED_BUFFER_SIZE = 65;
263 const uint8_t DRM_AUDIO_ENCRYPTED_BUFFER[] = {
264 0x41, 0x55, 0xf7, 0x4f, 0xbb, 0x05, 0x15, 0xec, 0x11, 0xba, 0x98, 0x92, 0xdc, 0x21, 0x72, 0x75,
265 0x52, 0xfd, 0x9b, 0xff, 0x6c, 0x13, 0x75, 0x32, 0x11, 0x9a, 0x1c, 0xd4, 0xac, 0x58, 0x2c, 0x9a,
266 0x27, 0x4a, 0xab, 0x5c, 0x5b, 0x5e, 0xe1, 0xe8, 0xb9, 0x80, 0x9b, 0x0c, 0x63, 0xd8, 0xd1, 0xd8,
267 0xee, 0x8f, 0xce, 0x56, 0x14, 0xb2, 0xad, 0x30, 0x56, 0x7a, 0x22, 0x72, 0x85, 0x21, 0x1e, 0x47,
268 0x75}; // 65
269 }
270
271 namespace OHOS {
272 namespace DrmDecryptorFuzzer {
273
CreateH264MediaCencInfo(MetaDrmCencInfo & cencInfo)274 void CreateH264MediaCencInfo(MetaDrmCencInfo &cencInfo)
275 {
276 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
277 memcpy_s(cencInfo.keyId, sizeof(cencInfo.keyId), DRM_H264_KEY_ID, sizeof(cencInfo.keyId));
278 cencInfo.keyIdLen = KEY_ID_LEN;
279 memcpy_s(cencInfo.iv, sizeof(cencInfo.iv), DRM_H264_IV, sizeof(cencInfo.iv));
280 cencInfo.ivLen = IV_LEN;
281 cencInfo.encryptBlocks = 0;
282 cencInfo.skipBlocks = 0;
283 cencInfo.firstEncryptOffset = 0;
284 cencInfo.subSampleNum = 1;
285 cencInfo.mode = MetaDrmCencInfoMode::META_DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET;
286
287 cencInfo.subSamples[0].clearHeaderLen = DRM_H264_ENCRYPTED_BUFFER_SIZE;
288 cencInfo.subSamples[0].payLoadLen = 0;
289 }
290
SetH264MediaData(std::shared_ptr<AVBuffer> drmInBuf,MetaDrmCencInfo & cencInfo,uint32_t mode)291 bool SetH264MediaData(std::shared_ptr<AVBuffer> drmInBuf, MetaDrmCencInfo &cencInfo, uint32_t mode)
292 {
293 int32_t drmRes = 0;
294 switch (mode) {
295 case 0x1: // 0x1:SM4-SAMPL SM4S
296 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
297 drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_H264_ENCRYPTED_BUFFER_SIZE,
298 DRM_H264_SM4S_ENCRYPTED_BUFFER, DRM_H264_ENCRYPTED_BUFFER_SIZE);
299 break;
300 case 0x2: // 0x2:AES CBCS
301 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_AES_CBC;
302 drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_H264_ENCRYPTED_BUFFER_SIZE,
303 DRM_H264_CBCS_ENCRYPTED_BUFFER, DRM_H264_ENCRYPTED_BUFFER_SIZE);
304 break;
305 case 0x5: // 0x5:AES CBC1
306 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_AES_CBC;
307 drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_H264_ENCRYPTED_BUFFER_SIZE,
308 DRM_H264_CBC1_ENCRYPTED_BUFFER, DRM_H264_ENCRYPTED_BUFFER_SIZE);
309 break;
310 case 0x3: // 0x3:SM4-CBC SM4C
311 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
312 drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_H264_ENCRYPTED_BUFFER_SIZE,
313 DRM_H264_SM4C_ENCRYPTED_BUFFER, DRM_H264_ENCRYPTED_BUFFER_SIZE);
314 break;
315 case 0x0: // 0x0:NONE
316 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_UNENCRYPTED;
317 drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_H264_ENCRYPTED_BUFFER_SIZE,
318 DRM_H264_NONE_ENCRYPTED_BUFFER, DRM_H264_ENCRYPTED_BUFFER_SIZE);
319 break;
320 default:
321 break;
322 }
323 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
324 return true;
325 }
326
H264MediaCencDecrypt(std::shared_ptr<AVBuffer> drmInBuf,std::shared_ptr<AVBuffer> drmOutBuf,std::shared_ptr<CodecDrmDecrypt> decryptor,uint32_t mode,int32_t flag)327 void H264MediaCencDecrypt(std::shared_ptr<AVBuffer> drmInBuf, std::shared_ptr<AVBuffer> drmOutBuf,
328 std::shared_ptr<CodecDrmDecrypt> decryptor, uint32_t mode, int32_t flag)
329 {
330 MetaDrmCencInfo cencInfo;
331 CreateH264MediaCencInfo(cencInfo);
332 SetH264MediaData(drmInBuf, cencInfo, mode);
333 if (flag == 1) {
334 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
335 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
336 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
337 }
338 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, DRM_H264_ENCRYPTED_BUFFER_SIZE);
339 }
340
CreateHevcMediaCencInfo(MetaDrmCencInfo & cencInfo)341 void CreateHevcMediaCencInfo(MetaDrmCencInfo &cencInfo)
342 {
343 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
344 memcpy_s(cencInfo.keyId, sizeof(cencInfo.keyId), DRM_HEVC_SM4C_KEY_ID, sizeof(cencInfo.keyId));
345 cencInfo.keyIdLen = KEY_ID_LEN;
346 memcpy_s(cencInfo.iv, sizeof(cencInfo.iv), DRM_HEVC_SM4C_IV, sizeof(cencInfo.iv));
347 cencInfo.ivLen = IV_LEN;
348 cencInfo.encryptBlocks = 0;
349 cencInfo.skipBlocks = 0;
350 cencInfo.firstEncryptOffset = 0;
351 cencInfo.subSampleNum = 1;
352 cencInfo.mode = MetaDrmCencInfoMode::META_DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET;
353
354 cencInfo.subSamples[0].clearHeaderLen = DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE;
355 cencInfo.subSamples[0].payLoadLen = 0;
356 }
357
CreateAvsMediaCencInfo(MetaDrmCencInfo & cencInfo)358 void CreateAvsMediaCencInfo(MetaDrmCencInfo &cencInfo)
359 {
360 cencInfo.algo = MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC;
361 memcpy_s(cencInfo.keyId, sizeof(cencInfo.keyId), DRM_AVS_SM4C_KEY_ID, sizeof(cencInfo.keyId));
362 cencInfo.keyIdLen = KEY_ID_LEN;
363 memcpy_s(cencInfo.iv, sizeof(cencInfo.iv), DRM_AVS_SM4C_IV, sizeof(cencInfo.iv));
364 cencInfo.ivLen = IV_LEN;
365 cencInfo.encryptBlocks = 0;
366 cencInfo.skipBlocks = 0;
367 cencInfo.firstEncryptOffset = 0;
368 cencInfo.subSampleNum = 1;
369 cencInfo.mode = MetaDrmCencInfoMode::META_DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET;
370
371 cencInfo.subSamples[0].clearHeaderLen = DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE;
372 cencInfo.subSamples[0].payLoadLen = 0;
373 }
374
CreateAudioCencInfo(MetaDrmCencInfo & cencInfo,MetaDrmCencAlgorithm algo)375 void CreateAudioCencInfo(MetaDrmCencInfo &cencInfo, MetaDrmCencAlgorithm algo)
376 {
377 cencInfo.algo = algo;
378 memcpy_s(cencInfo.keyId, sizeof(cencInfo.keyId), DRM_AUDIO_KEY_ID, sizeof(cencInfo.keyId));
379 cencInfo.keyIdLen = KEY_ID_LEN;
380 memcpy_s(cencInfo.iv, sizeof(cencInfo.iv), DRM_AUDIO_IV, sizeof(cencInfo.iv));
381 cencInfo.ivLen = IV_LEN;
382 cencInfo.encryptBlocks = 0;
383 cencInfo.skipBlocks = 0;
384 cencInfo.firstEncryptOffset = 0;
385 cencInfo.subSampleNum = 0;
386 cencInfo.mode = MetaDrmCencInfoMode::META_DRM_CENC_INFO_KEY_IV_SUBSAMPLES_SET;
387 }
388
AudioCencDecrypt(std::shared_ptr<AVBuffer> drmInBuf,std::shared_ptr<AVBuffer> drmOutBuf,std::shared_ptr<CodecDrmDecrypt> decryptor,MetaDrmCencAlgorithm algo,int32_t flag)389 bool AudioCencDecrypt(std::shared_ptr<AVBuffer> drmInBuf, std::shared_ptr<AVBuffer> drmOutBuf,
390 std::shared_ptr<CodecDrmDecrypt> decryptor, MetaDrmCencAlgorithm algo, int32_t flag)
391 {
392 MetaDrmCencInfo cencInfo;
393 CreateAudioCencInfo(cencInfo, algo);
394
395 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_AUDIO_ENCRYPTED_BUFFER_SIZE,
396 DRM_AUDIO_ENCRYPTED_BUFFER, DRM_AUDIO_ENCRYPTED_BUFFER_SIZE);
397 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
398
399 if (flag == 1) {
400 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
401 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
402 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
403 }
404 decryptor->DrmAudioCencDecrypt(drmInBuf, drmOutBuf, DRM_AUDIO_ENCRYPTED_BUFFER_SIZE);
405 return true;
406 }
407
SetCodecNameFuzzTest(FuzzedDataProvider * provider)408 bool SetCodecNameFuzzTest(FuzzedDataProvider *provider)
409 {
410 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
411 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
412 static uint8_t setCodecNameFuzzTestFlag = 0;
413 if (setCodecNameFuzzTestFlag == 0) {
414 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avc");
415 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.hevc");
416 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avs");
417 decryptor->SetCodecName("OH.Media.Codec.Decoder.Audio.mp4a-latm");
418 setCodecNameFuzzTestFlag = 1;
419 }
420 std::string codecName = provider->ConsumeRandomLengthString();
421 decryptor->SetCodecName(codecName);
422 return true;
423 }
424
425 #ifdef SUPPORT_DRM
SetDecryptionConfigFuzzTest(FuzzedDataProvider * provider)426 bool SetDecryptionConfigFuzzTest(FuzzedDataProvider *provider)
427 {
428 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
429 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
430 static uint8_t setDecryptionConfigFuzzTestFlag = 0;
431 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
432 if (setDecryptionConfigFuzzTestFlag == 0) {
433 bool svpFlag = false;
434 decryptor->SetDecryptionConfig(session, svpFlag);
435 setDecryptionConfigFuzzTestFlag = 1;
436 }
437 bool svpFlag = provider->ConsumeBool();
438 decryptor->SetDecryptionConfig(session, svpFlag);
439 return true;
440 }
441
DrmH264VideoCencDecrypt()442 bool DrmH264VideoCencDecrypt()
443 {
444 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
445 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
446
447 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avc");
448
449 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
450 bool svpFlag = false;
451 decryptor->SetDecryptionConfig(session, svpFlag);
452
453 MemoryFlag memFlag = MEMORY_READ_WRITE;
454 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
455 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
456 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator,
457 static_cast<int32_t>(DRM_H264_ENCRYPTED_BUFFER_SIZE));
458 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
459 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
460 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
461 (drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_H264_ENCRYPTED_BUFFER_SIZE)), false);
462 drmInBuf->memory_->SetSize(DRM_H264_ENCRYPTED_BUFFER_SIZE);
463
464 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator,
465 static_cast<int32_t>(DRM_H264_ENCRYPTED_BUFFER_SIZE));
466 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
467 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
468 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
469 (drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_H264_ENCRYPTED_BUFFER_SIZE)), false);
470
471 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x0, 0);
472 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x1, 1); // 0x1:SM4-SAMPL SM4S
473 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x2, 1); // 0x2:AES CBCS
474 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x5, 1); // 0x5:AES CBC1
475 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x3, 1); // 0x3:SM4-CBC SM4C
476 H264MediaCencDecrypt(drmInBuf, drmOutBuf, decryptor, 0x0, 1); // 0x0:NONE
477 drmOutBuf->memory_->SetSize(DRM_H264_ENCRYPTED_BUFFER_SIZE);
478 return true;
479 }
480
DrmH264VideoCencDecryptFuzzTest()481 bool DrmH264VideoCencDecryptFuzzTest()
482 {
483 uint32_t dataSize = static_cast<uint32_t>(fuzzSize);
484 static uint8_t drmH264VideoCencDecryptFuzzTestFlag = 0;
485 if (drmH264VideoCencDecryptFuzzTestFlag == 0) {
486 DrmH264VideoCencDecrypt();
487 drmH264VideoCencDecryptFuzzTestFlag = 1;
488 }
489 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
490 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
491
492 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avc");
493
494 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
495 bool svpFlag = false;
496 decryptor->SetDecryptionConfig(session, svpFlag);
497
498 MemoryFlag memFlag = MEMORY_READ_WRITE;
499 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
500 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
501 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
502 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
503 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
504 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
505 false);
506 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), dataSize, fuzzData, dataSize);
507 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
508 drmInBuf->memory_->SetSize(dataSize);
509
510 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
511 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
512 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
513 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
514 false);
515
516 MetaDrmCencInfo cencInfo;
517 CreateH264MediaCencInfo(cencInfo);
518 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
519 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
520 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
521 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, dataSize);
522 drmOutBuf->memory_->SetSize(dataSize);
523 return true;
524 }
525
DrmHevcVideoCencDecrypt()526 bool DrmHevcVideoCencDecrypt()
527 {
528 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
529 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
530
531 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.hevc");
532
533 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
534 bool svpFlag = false;
535 decryptor->SetDecryptionConfig(session, svpFlag);
536
537 MemoryFlag memFlag = MEMORY_READ_WRITE;
538 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
539 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
540 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator,
541 static_cast<int32_t>(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE));
542 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
543 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
544 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
545 (drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE)), false);
546 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE,
547 DRM_HEVC_SM4C_ENCRYPTED_BUFFER, DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE);
548 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
549 drmInBuf->memory_->SetSize(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE);
550
551 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator,
552 static_cast<int32_t>(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE));
553 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
554 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
555 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
556 (drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE)), false);
557
558 MetaDrmCencInfo cencInfo;
559 CreateHevcMediaCencInfo(cencInfo);
560 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
561 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
562 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
563 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE);
564 drmOutBuf->memory_->SetSize(DRM_HEVC_SM4C_ENCRYPTED_BUFFER_SIZE);
565 return true;
566 }
567
DrmHevcVideoCencDecryptFuzzTest()568 bool DrmHevcVideoCencDecryptFuzzTest()
569 {
570 uint32_t dataSize = static_cast<uint32_t>(fuzzSize);
571 static uint8_t drmHevcVideoCencDecryptFuzzTestFlag = 0;
572 if (drmHevcVideoCencDecryptFuzzTestFlag == 0) {
573 DrmHevcVideoCencDecrypt();
574 drmHevcVideoCencDecryptFuzzTestFlag = 1;
575 }
576 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
577 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
578
579 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.hevc");
580
581 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
582 bool svpFlag = false;
583 decryptor->SetDecryptionConfig(session, svpFlag);
584
585 MemoryFlag memFlag = MEMORY_READ_WRITE;
586 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
587 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
588 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
589 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
590 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
591 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
592 false);
593 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), dataSize, fuzzData, dataSize);
594 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
595 drmInBuf->memory_->SetSize(dataSize);
596
597 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
598 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
599 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
600 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
601 false);
602
603 MetaDrmCencInfo cencInfo;
604 CreateHevcMediaCencInfo(cencInfo);
605 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
606 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
607 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
608 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, dataSize);
609 drmOutBuf->memory_->SetSize(dataSize);
610 return true;
611 }
612
DrmAvsVideoCencDecrypt()613 bool DrmAvsVideoCencDecrypt()
614 {
615 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
616 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
617
618 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avs");
619
620 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
621 bool svpFlag = false;
622 decryptor->SetDecryptionConfig(session, svpFlag);
623
624 MemoryFlag memFlag = MEMORY_READ_WRITE;
625 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
626 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
627 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator,
628 static_cast<int32_t>(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE));
629 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
630 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
631 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
632 (drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE)), false);
633 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE,
634 DRM_AVS_SM4C_ENCRYPTED_BUFFER, DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE);
635 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
636 drmInBuf->memory_->SetSize(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE);
637
638 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator,
639 static_cast<int32_t>(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE));
640 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
641 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
642 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
643 (drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE)), false);
644
645 MetaDrmCencInfo cencInfo;
646 CreateAvsMediaCencInfo(cencInfo);
647 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
648 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
649 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
650 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE);
651 drmOutBuf->memory_->SetSize(DRM_AVS_SM4C_ENCRYPTED_BUFFER_SIZE);
652 return true;
653 }
654
DrmAvsVideoCencDecryptFuzzTest()655 bool DrmAvsVideoCencDecryptFuzzTest()
656 {
657 uint32_t dataSize = static_cast<uint32_t>(fuzzSize);
658 static uint8_t drmAvsVideoCencDecryptFuzzTestFlag = 0;
659 if (drmAvsVideoCencDecryptFuzzTestFlag == 0) {
660 DrmAvsVideoCencDecrypt();
661 drmAvsVideoCencDecryptFuzzTestFlag = 1;
662 }
663 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
664 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
665
666 decryptor->SetCodecName("OH.Media.Codec.Decoder.Video.avs");
667
668 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
669 bool svpFlag = false;
670 decryptor->SetDecryptionConfig(session, svpFlag);
671
672 MemoryFlag memFlag = MEMORY_READ_WRITE;
673 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
674 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
675 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
676 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
677 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
678 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
679 false);
680 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), dataSize, fuzzData, dataSize);
681 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
682 drmInBuf->memory_->SetSize(dataSize);
683
684 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
685 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
686 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
687 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
688 false);
689
690 MetaDrmCencInfo cencInfo;
691 CreateAvsMediaCencInfo(cencInfo);
692 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
693 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
694 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
695 decryptor->DrmVideoCencDecrypt(drmInBuf, drmOutBuf, dataSize);
696 drmOutBuf->memory_->SetSize(dataSize);
697 return true;
698 }
699
DrmAudioCencDecryptTest()700 bool DrmAudioCencDecryptTest()
701 {
702 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
703 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
704 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
705 bool svpFlag = false;
706 decryptor->SetDecryptionConfig(session, svpFlag);
707
708 MemoryFlag memFlag = MEMORY_READ_WRITE;
709 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
710 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
711 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator,
712 static_cast<int32_t>(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE));
713 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
714 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
715 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
716 (drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE)), false);
717 drmInBuf->memory_->SetSize(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE);
718
719 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator,
720 static_cast<int32_t>(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE));
721 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
722 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
723 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(
724 (drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE)), false);
725
726 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_UNENCRYPTED, 0);
727 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_AES_CTR, 1);
728 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CTR, 1);
729 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_AES_CBC, 1);
730 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_SM4_CBC, 1);
731 AudioCencDecrypt(drmInBuf, drmOutBuf, decryptor, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_UNENCRYPTED, 1);
732 drmOutBuf->memory_->SetSize(DRM_AUDIO_ENCRYPTED_BUFFER_SIZE);
733 return true;
734 }
735
DrmAudioCencDecryptFuzzTest()736 bool DrmAudioCencDecryptFuzzTest()
737 {
738 uint32_t dataSize = static_cast<uint32_t>(fuzzSize);
739 static uint8_t drmAudioCencDecryptFuzzTestFlag = 0;
740 if (drmAudioCencDecryptFuzzTestFlag == 0) {
741 DrmAudioCencDecryptTest();
742 drmAudioCencDecryptFuzzTestFlag = 1;
743 }
744 std::shared_ptr<CodecDrmDecrypt> decryptor = std::make_shared<CodecDrmDecrypt>();
745 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(decryptor != nullptr, false);
746 sptr<DrmStandard::IMediaKeySessionService> session = nullptr;
747 bool svpFlag = false;
748 decryptor->SetDecryptionConfig(session, svpFlag);
749
750 MemoryFlag memFlag = MEMORY_READ_WRITE;
751 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
752 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(avAllocator != nullptr, false);
753 std::shared_ptr<AVBuffer> drmInBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
754 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf != nullptr, false);
755 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_ != nullptr, false);
756 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmInBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
757 false);
758 int32_t drmRes = memcpy_s(drmInBuf->memory_->GetAddr(), dataSize, fuzzData, dataSize);
759 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmRes == 0, false);
760 drmInBuf->memory_->SetSize(dataSize);
761
762 std::shared_ptr<AVBuffer> drmOutBuf = AVBuffer::CreateAVBuffer(avAllocator, static_cast<int32_t>(dataSize));
763 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf != nullptr, false);
764 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_ != nullptr, false);
765 DRM_DECRYPTOR_FUZZ_CHECK_AND_RETURN_RET(drmOutBuf->memory_->GetCapacity() == static_cast<int32_t>(dataSize),
766 false);
767
768 MetaDrmCencInfo cencInfo;
769 CreateAudioCencInfo(cencInfo, MetaDrmCencAlgorithm::META_DRM_ALG_CENC_AES_CBC);
770 std::vector<uint8_t> drmCencVec(reinterpret_cast<uint8_t *>(&cencInfo),
771 (reinterpret_cast<uint8_t *>(&cencInfo)) + sizeof(MetaDrmCencInfo));
772 drmInBuf->meta_->SetData(Media::Tag::DRM_CENC_INFO, std::move(drmCencVec));
773 decryptor->DrmAudioCencDecrypt(drmInBuf, drmOutBuf, dataSize);
774 drmOutBuf->memory_->SetSize(dataSize);
775 return true;
776 }
777 #endif
778
779 } // namespace DrmDecryptorFuzzer
780 } // namespace OHOS
781
782 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)783 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
784 {
785 /* Run your code on data */
786 if (data == nullptr) {
787 return 0;
788 }
789 if (size < sizeof(int64_t)) {
790 return 0;
791 }
792 fuzzData = data;
793 fuzzSize = size;
794 FuzzedDataProvider fdp(data, size);
795 OHOS::DrmDecryptorFuzzer::SetCodecNameFuzzTest(&fdp);
796 #ifdef SUPPORT_DRM
797 OHOS::DrmDecryptorFuzzer::SetDecryptionConfigFuzzTest(&fdp);
798 OHOS::DrmDecryptorFuzzer::DrmH264VideoCencDecryptFuzzTest();
799 OHOS::DrmDecryptorFuzzer::DrmHevcVideoCencDecryptFuzzTest();
800 OHOS::DrmDecryptorFuzzer::DrmAvsVideoCencDecryptFuzzTest();
801 OHOS::DrmDecryptorFuzzer::DrmAudioCencDecryptFuzzTest();
802 #endif
803 return 0;
804 }
805