Debian Codegraph @

oss-fuzz/seek.cc

raw
1 /* fuzzer_seek
2 * Copyright (C) 2022-2025 Xiph.Org Foundation
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * - Neither the name of the Xiph.org Foundation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <cstdlib>
33 #include <cstring> /* for memcpy */
34 #include "FLAC/stream_decoder.h"
35 #include "common.h"
36
37 #if MSAN == 1
38 extern "C" void __msan_check_mem_is_initialized(const volatile void *x, size_t size);
39 #endif
40
41 int write_abort_check_counter = -1;
42 int written_uncompressed_bytes = 0;
43 int errors_received_counter = 0;
44
45 #if 0 /* set to 1 to debug */
46 #define FPRINTF_DEBUG_ONLY(...) fprintf(__VA_ARGS__)
47 #else
48 #define FPRINTF_DEBUG_ONLY(...)
49 #endif
50
51 #define CONFIG_LENGTH 3
52
53 static FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const buffer[], void *client_data)
54 {
55 (void)decoder, (void)buffer, (void)client_data;
56 if(write_abort_check_counter > 0) {
57 write_abort_check_counter--;
58 if(write_abort_check_counter == 0)
59 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
60 } else if(write_abort_check_counter == 0)
61 /* This must not happen: write callback called after abort is returned */
62 abort();
63
64 written_uncompressed_bytes += frame->header.blocksize * frame->header.channels * frame->header.bits_per_sample / 8;
65 if(written_uncompressed_bytes > (1 << 24))
66 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
67
68
69 if(errors_received_counter > 10000)
70 return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
71
72 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
73 }
74
75 static void error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus error, void *client_data)
76 {
77 (void)decoder, (void)error, (void)client_data;
78 errors_received_counter++;
79 }
80
81
82 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
83 {
84 FLAC__bool decoder_valid = true;
85 FLAC__StreamDecoder *decoder;
86 uint8_t command_length;
87 FLAC__bool init_bools[16], ogg;
88
89 if(size < 1)
90 return 1;
91
92 if(data[0] < 128) /* Use MSB as on/off */
93 alloc_check_threshold = data[0];
94 else
95 alloc_check_threshold = INT32_MAX;
96 alloc_check_counter = 0;
97
98 write_abort_check_counter = -1;
99 written_uncompressed_bytes = 0;
100 errors_received_counter = 0;
101
102 /* allocate the decoder */
103 if((decoder = FLAC__stream_decoder_new()) == NULL) {
104 return 1;
105 }
106
107 /* Use first CONFIG_LENGTH bytes for configuration, leave at least one byte of input */
108 if(size < 1 + CONFIG_LENGTH){
109 FLAC__stream_decoder_delete(decoder);
110 return 0;
111 }
112
113 /* bit 8 to 19 bits for configuration bools, bit 20 to 23 for length of command section */
114 for(int i = 0; i < 12; i++)
115 init_bools[i] = data[1+i/8] & (1 << (i % 8));
116
117 command_length = data[CONFIG_LENGTH-1] >> 4;
118
119 /* Leave at least one byte as input */
120 if(command_length >= size - 1 - CONFIG_LENGTH)
121 command_length = size - 1 - CONFIG_LENGTH;
122
123 /* Dump decoder input to file */
124 {
125 FILE * file_to_decode = fopen("/tmp/tmp.flac","w");
126 fwrite(data+CONFIG_LENGTH+command_length,1,size-CONFIG_LENGTH-command_length,file_to_decode);
127 fclose(file_to_decode);
128 }
129
130 ogg = init_bools[0];
131
132 FLAC__stream_decoder_set_md5_checking(decoder,init_bools[1]);
133 if(init_bools[2])
134 FLAC__stream_decoder_set_metadata_respond_all(decoder);
135 if(init_bools[3])
136 FLAC__stream_decoder_set_metadata_ignore_all(decoder);
137 if(init_bools[4])
138 FLAC__stream_decoder_set_decode_chained_stream(decoder, true);
139
140 /* initialize decoder */
141 if(decoder_valid) {
142 FLAC__StreamDecoderInitStatus init_status;
143 if(ogg)
144 init_status = FLAC__stream_decoder_init_ogg_file(decoder, "/tmp/tmp.flac", write_callback, NULL, error_callback, NULL);
145 else
146 init_status = FLAC__stream_decoder_init_file(decoder, "/tmp/tmp.flac", write_callback, NULL, error_callback, NULL);
147 if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
148 decoder_valid = false;
149 }
150 }
151
152 /* Run commands */
153 for(uint8_t i = 0; decoder_valid && (i < command_length); i++){
154 const uint8_t * command = data+CONFIG_LENGTH+i;
155 uint8_t shift = 1u << (command[0] >> 3);
156 FLAC__uint64 seekpos;
157
158 switch(command[0] & 15){
159 case 0:
160 FPRINTF_DEBUG_ONLY(stderr,"end_of_stream\n");
161 decoder_valid = FLAC__stream_decoder_process_until_end_of_stream(decoder);
162 break;
163 case 1:
164 FPRINTF_DEBUG_ONLY(stderr,"end_of_metadata\n");
165 decoder_valid = FLAC__stream_decoder_process_until_end_of_metadata(decoder);
166 break;
167 case 2:
168 FPRINTF_DEBUG_ONLY(stderr,"single\n");
169 decoder_valid = FLAC__stream_decoder_process_single(decoder);
170 break;
171 case 3:
172 FPRINTF_DEBUG_ONLY(stderr,"skip_single\n");
173 decoder_valid = FLAC__stream_decoder_skip_single_frame(decoder);
174 break;
175 case 4:
176 FPRINTF_DEBUG_ONLY(stderr,"reset\n");
177 decoder_valid = FLAC__stream_decoder_reset(decoder);
178 break;
179 case 5:
180 FPRINTF_DEBUG_ONLY(stderr,"flush\n");
181 decoder_valid = FLAC__stream_decoder_flush(decoder);
182 break;
183 case 6:
184 case 14:
185 shift = 1u << (command[0] >> 3);
186 FPRINTF_DEBUG_ONLY(stderr,"seek short %hhu\n",shift);
187 decoder_valid = FLAC__stream_decoder_seek_absolute(decoder,shift);
188 break;
189 case 7:
190 if(i+8 >= command_length) /* Not enough data available to do this */
191 break;
192 seekpos = ((FLAC__uint64)command[1] << 56) +
193 ((FLAC__uint64)command[2] << 48) +
194 ((FLAC__uint64)command[3] << 40) +
195 ((FLAC__uint64)command[4] << 32) +
196 ((FLAC__uint64)command[5] << 24) +
197 ((FLAC__uint64)command[6] << 16) +
198 ((FLAC__uint64)command[7] << 8) +
199 command[8];
200 i+=8;
201 FPRINTF_DEBUG_ONLY(stderr,"seek long %lu\n",seekpos);
202 decoder_valid = FLAC__stream_decoder_seek_absolute(decoder,seekpos);
203 break;
204 case 8:
205 /* Set abort on write callback */
206 write_abort_check_counter = (command[0] >> 4) + 1;
207 break;
208 case 9:
209 FPRINTF_DEBUG_ONLY(stderr,"end_of_link\n");
210 decoder_valid = FLAC__stream_decoder_process_until_end_of_link(decoder);
211 break;
212 case 10:
213 FPRINTF_DEBUG_ONLY(stderr,"finish_link\n");
214 if(FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_LINK)
215 FLAC__stream_decoder_finish_link(decoder);
216 break;
217 case 11:
218 FPRINTF_DEBUG_ONLY(stderr,"skip_single_link\n");
219 decoder_valid = FLAC__stream_decoder_skip_single_link(decoder);
220 break;
221 case 12:
222 FPRINTF_DEBUG_ONLY(stderr,"find_total_samples\n");
223 if(FLAC__stream_decoder_find_total_samples(decoder) == 0) {
224 FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
225 if(state == FLAC__STREAM_DECODER_OGG_ERROR ||
226 state == FLAC__STREAM_DECODER_SEEK_ERROR ||
227 state == FLAC__STREAM_DECODER_ABORTED ||
228 state == FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR ||
229 state == FLAC__STREAM_DECODER_UNINITIALIZED)
230 decoder_valid = false;
231 }
232 break;
233 case 13:
234 int32_t retval;
235 FLAC__uint64 *link_lengths;
236 FPRINTF_DEBUG_ONLY(stderr,"get_link_lengths\n");
237 retval = FLAC__stream_decoder_get_link_lengths(decoder, &link_lengths);
238 if(retval == FLAC__STREAM_DECODER_GET_LINK_LENGTHS_MEMORY_ALLOCATION_ERROR) {
239 decoder_valid = false;
240 }
241 if(retval > 0) {
242 for(int32_t j = 0; j < retval; j++) {
243 #if MSAN == 1
244 __msan_check_mem_is_initialized(&link_lengths[j],sizeof(link_lengths[j]));
245 #else
246 ;
247 #endif
248 }
249 free(link_lengths);
250 }
251 break;
252 /* case 14 is already used above */
253 }
254 if(!decoder_valid) {
255 /* Try again if possible */
256 FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
257 if(state != FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR && state != FLAC__STREAM_DECODER_ABORTED) {
258 FPRINTF_DEBUG_ONLY(stderr,"reset invalid\n");
259 decoder_valid = FLAC__stream_decoder_reset(decoder);
260 }
261 }
262 }
263
264 FLAC__stream_decoder_finish(decoder);
265
266 FLAC__stream_decoder_delete(decoder);
267
268 return 0;
269 }
270