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