/src/gzio_fuzzer.c

Source
/********************************************************************************
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *******************************************************************************/
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <inttypes.h>
#include "zlib.h"

#undef gzgetc

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen) {

    gzFile file;
    char fname[] = "gzio.XXXXXX";
    close(mkstemp(fname));
    unsigned mode_sz = (dataLen ? (--dataLen, *data++) | 2 : 8) & 0xF;
    char mode[mode_sz];
    memcpy(mode, data, dataLen >= mode_sz ? mode_sz - 1: dataLen);
    mode[mode_sz - 1] = 0;
    file = gzopen(fname, mode);

    /* Chain I/O operations on a file opened with random mode the nature of the
     * operation and their operand are controlled by the fuzzer
     */
    int op_count = 2; //< Number of operations chained.
    while(op_count-- && dataLen > 0) {
      switch((--dataLen, (*data++)%26)) {
        case 0: {
          char c = dataLen ? (--dataLen, (char)*data++) : 'c';
          if(gzputc(file, c) < 0) {
            goto exit;
          }
          break;
        }
        case 1: {
          unsigned sz = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
          char input[sz];
          memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
          input[sz - 1] = 0;
          if(gzputs(file, input) < 0)
            goto exit;
          break;
        }
        case 2: {
          unsigned sz = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
          unsigned nitems = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
          unsigned count = sz * nitems;
          char input[count];
          memcpy(input, data, dataLen >= count ? count - 1: dataLen);
          input[count - 1] = 0;
          if(gzfwrite(input, sz, nitems, file) <= 0)
            goto exit;
          break;
        }
        case 3: {
          unsigned sz = dataLen ? (--dataLen, *data++) : 8;
          char uncompr[sz];
          if(gzread(file, uncompr, sz) < 0)
            goto exit;
          break;
        }
        case 4: {
          int whences[5] = {SEEK_CUR, SEEK_SET, SEEK_END, 18};
          int whence = dataLen ? (--dataLen, whences[(*data++)%5]) : SEEK_CUR;
          long offset = dataLen >= sizeof(long) ? (*(long*)data &0xFF) + 1: 1L;
          if(gzseek(file, offset, whence) < 0)
            goto exit;
          break;
        }
        case 5:
          gztell(file);
          break;
        case 6:
          gzgetc(file);
          break;
        case 7: {
          char c = dataLen ? (--dataLen, (char)*data++) : 'c';
          if(gzungetc(c, file) < 0)
            goto exit;
          break;
        }
        case 8: {
          unsigned sz = dataLen ? (--dataLen, *data++) : 8;
          char uncompr[sz];
          if(gzgets(file, uncompr, sz) < 0)
            goto exit;
          break;
        }
        case 9: {
          int level = dataLen ? (--dataLen, *data++) : 1;
          int strat = dataLen ? (--dataLen, *data++) : 2;
          if(gzsetparams(file, level, strat) < 0)
            goto exit;
          break;
        }
        case 10: {
          int flush = dataLen ? (--dataLen, *data++) : 0;
          gzflush(file, flush); break;
        }
        case 11: {
          static const char formats [][4] = { "%d", "%f", "%c", "%s" };
          int nformat = dataLen ? (--dataLen, *data++)%5 : 1;
          switch(nformat) {
            case 0: {
              int value = dataLen >= sizeof(int) ? *(int*)data : 1;
              gzprintf(file, formats[nformat], value);
              break;
            }
            case 1: {
              float value = dataLen >= sizeof(float) ? *(float*)data : 1;
              gzprintf(file, formats[nformat], value);
              break;
            }
            case 2: {
              char value = dataLen >= sizeof(char) ? *(char*)data : 1;
              gzprintf(file, formats[nformat], value);
              break;
            }
            case 3: {
             unsigned sz = dataLen ? ((--dataLen, *data++)&0xF)+1 : 8;
             char input[sz];
             memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
             input[sz - 1] = 0;
             gzprintf(file, formats[nformat], input);
             break;
            }
            default: {
             unsigned sz = dataLen ? ((--dataLen, *data++)&0xF)+1 : 8;
             char input[sz] = {};
             memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
             for(int i = 0; i < sz - 1; ++i)
               if(input[i] == '%') input[i] = '!';
             gzprintf(file, input);
             break;
            }
          };
          break;
        }
        case 12: {
          gzoffset(file);
          break;
        }
        case 13: {
          gzrewind(file);
          break;
        }
        case 14: {
          gzeof(file);
          break;
        }
        case 15: {
          gzdirect(file);
          break;
        }
        case 16: {
          unsigned sz = dataLen ? ((--dataLen, *data++))|1 : 128;
          if(gzbuffer(file, sz) <0)
            goto exit;
          break;
        }
        case 17: {
          int errnum;
          gzerror(file, &errnum);
          break;
        }
        case 18: {
          gzclearerr(file);
          break;
        }
        case 19: {
          unsigned sz = dataLen ? (--dataLen, *data++) : 8;
          unsigned nitems = dataLen ? (--dataLen, *data++) : 8;
          char buffer[sz * nitems];
          if(gzfread(buffer, sz, nitems, file) < 0)
            goto exit;
          break;
        }
        case 20: {
          gzgetc_(file);
          break;
        }
        case 21: {
          gzclose(file);
          file = NULL;
          break;
        }
        case 22: {
          zlibVersion();
          break;
        }
        case 23: {
          zlibCompileFlags();
          break;
        }
        case 24: {
          get_crc_table();
          break;
        }
        case 25: {
          unsigned err = dataLen ? (--dataLen, *data++) : 0;
          zError(err);
          break;
        }
      }
    }
    gzclose(file);
    remove(fname);
  return 0;
exit:
    gzclose(file);
    remove(fname);
  return -1;
}

Coverage Report

Created: 2026-10-17 07:03

Line	Count	Source
1		/********************************************************************************
2		* Copyright 2025 Google LLC
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*
16		*******************************************************************************/
17		#include <stdio.h>
18		#include <stddef.h>
19		#include <stdint.h>
20		#include <string.h>
21		#include <assert.h>
22		#include <stdlib.h>
23		#include <inttypes.h>
24		#include "zlib.h"
25
26		#undef gzgetc
27
28	2.05k	int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen) {
29
30	2.05k	gzFile file;
31	2.05k	char fname[] = "gzio.XXXXXX";
32	2.05k	close(mkstemp(fname));
33	2.05k	unsigned mode_sz = (dataLen ? (--dataLen, *data++) \| 2 : 8) & 0xF;
34	2.05k	char mode[mode_sz];
35	2.05k	memcpy(mode, data, dataLen >= mode_sz ? mode_sz - 1: dataLen);
36	2.05k	mode[mode_sz - 1] = 0;
37	2.05k	file = gzopen(fname, mode);
38
39		/* Chain I/O operations on a file opened with random mode the nature of the
40		* operation and their operand are controlled by the fuzzer
41		*/
42	2.05k	int op_count = 2; //< Number of operations chained.
43	5.79k	while(op_count-- && dataLen > 0) {
44	3.82k	switch((--dataLen, (*data++)%26)) {
45	104	case 0: {
46	104	char c = dataLen ? (--dataLen, (char)*data++) : 'c';
47	104	if(gzputc(file, c) < 0) {
48	16	goto exit;
49	16	}
50	88	break;
51	104	}
52	152	case 1: {
53	152	unsigned sz = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
54	152	char input[sz];
55	152	memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
56	152	input[sz - 1] = 0;
57	152	if(gzputs(file, input) < 0)
58	7	goto exit;
59	145	break;
60	152	}
61	1.04k	case 2: {
62	1.04k	unsigned sz = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
63	1.04k	unsigned nitems = dataLen ? ((--dataLen, *data++)&0xF) + 1 : 8;
64	1.04k	unsigned count = sz * nitems;
65	1.04k	char input[count];
66	1.04k	memcpy(input, data, dataLen >= count ? count - 1: dataLen);
67	1.04k	input[count - 1] = 0;
68	1.04k	if(gzfwrite(input, sz, nitems, file) <= 0)
69	16	goto exit;
70	1.03k	break;
71	1.04k	}
72	1.03k	case 3: {
73	46	unsigned sz = dataLen ? (--dataLen, *data++) : 8;
74	46	char uncompr[sz];
75	46	if(gzread(file, uncompr, sz) < 0)
76	5	goto exit;
77	41	break;
78	46	}
79	356	case 4: {
80	356	int whences[5] = {SEEK_CUR, SEEK_SET, SEEK_END, 18};
81	356	int whence = dataLen ? (--dataLen, whences[(*data++)%5]) : SEEK_CUR;
82	356	long offset = dataLen >= sizeof(long) ? ((long)data &0xFF) + 1: 1L;
83	356	if(gzseek(file, offset, whence) < 0)
84	15	goto exit;
85	341	break;
86	356	}
87	341	case 5:
88	15	gztell(file);
89	15	break;
90	34	case 6:
91	34	gzgetc(file);
92	34	break;
93	87	case 7: {
94	87	char c = dataLen ? (--dataLen, (char)*data++) : 'c';
95	87	if(gzungetc(c, file) < 0)
96	13	goto exit;
97	74	break;
98	87	}
99	76	case 8: {
100	76	unsigned sz = dataLen ? (--dataLen, *data++) : 8;
101	76	char uncompr[sz];
102	76	if(gzgets(file, uncompr, sz) < 0)
103	0	goto exit;
104	76	break;
105	76	}
106	208	case 9: {
107	208	int level = dataLen ? (--dataLen, *data++) : 1;
108	208	int strat = dataLen ? (--dataLen, *data++) : 2;
109	208	if(gzsetparams(file, level, strat) < 0)
110	7	goto exit;
111	201	break;
112	208	}
113	210	case 10: {
114	210	int flush = dataLen ? (--dataLen, *data++) : 0;
115	210	gzflush(file, flush); break;
116	208	}
117	515	case 11: {
118	515	static const char formats [][4] = { "%d", "%f", "%c", "%s" };
119	515	int nformat = dataLen ? (--dataLen, *data++)%5 : 1;
120	515	switch(nformat) {
121	59	case 0: {
122	59	int value = dataLen >= sizeof(int) ? (int)data : 1;
123	59	gzprintf(file, formats[nformat], value);
124	59	break;
125	0	}
126	119	case 1: {
127	119	float value = dataLen >= sizeof(float) ? (float)data : 1;
128	119	gzprintf(file, formats[nformat], value);
129	119	break;
130	0	}
131	69	case 2: {
132	69	char value = dataLen >= sizeof(char) ? (char)data : 1;
133	69	gzprintf(file, formats[nformat], value);
134	69	break;
135	0	}
136	107	case 3: {
137	107	unsigned sz = dataLen ? ((--dataLen, *data++)&0xF)+1 : 8;
138	107	char input[sz];
139	107	memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
140	107	input[sz - 1] = 0;
141	107	gzprintf(file, formats[nformat], input);
142	107	break;
143	0	}
144	161	default: {
145	161	unsigned sz = dataLen ? ((--dataLen, *data++)&0xF)+1 : 8;
146	161	char input[sz] = {};
147	161	memcpy(input, data, dataLen >= sz ? sz - 1: dataLen);
148	1.36k	for(int i = 0; i < sz - 1; ++i)
149	1.20k	if(input[i] == '%') input[i] = '!';
150	161	gzprintf(file, input);
151	161	break;
152	0	}
153	515	};
154	515	break;
155	515	}
156	19	case 12: {
157	19	gzoffset(file);
158	19	break;
159	515	}
160	15	case 13: {
161	15	gzrewind(file);
162	15	break;
163	515	}
164	18	case 14: {
165	18	gzeof(file);
166	18	break;
167	515	}
168	184	case 15: {
169	184	gzdirect(file);
170	184	break;
171	515	}
172	232	case 16: {
173	232	unsigned sz = dataLen ? ((--dataLen, *data++))\|1 : 128;
174	232	if(gzbuffer(file, sz) <0)
175	9	goto exit;
176	223	break;
177	232	}
178	223	case 17: {
179	19	int errnum;
180	19	gzerror(file, &errnum);
181	19	break;
182	232	}
183	24	case 18: {
184	24	gzclearerr(file);
185	24	break;
186	232	}
187	269	case 19: {
188	269	unsigned sz = dataLen ? (--dataLen, *data++) : 8;
189	269	unsigned nitems = dataLen ? (--dataLen, *data++) : 8;
190	269	char buffer[sz * nitems];
191	269	if(gzfread(buffer, sz, nitems, file) < 0)
192	0	goto exit;
193	269	break;
194	269	}
195	269	case 20: {
196	22	gzgetc_(file);
197	22	break;
198	269	}
199	31	case 21: {
200	31	gzclose(file);
201	31	file = NULL;
202	31	break;
203	269	}
204	25	case 22: {
205	25	zlibVersion();
206	25	break;
207	269	}
208	29	case 23: {
209	29	zlibCompileFlags();
210	29	break;
211	269	}
212	22	case 24: {
213	22	get_crc_table();
214	22	break;
215	269	}
216	65	case 25: {
217	65	unsigned err = dataLen ? (--dataLen, *data++) : 0;
218	65	zError(err);
219	65	break;
220	269	}
221	3.82k	}
222	3.82k	}
223	1.96k	gzclose(file);
224	1.96k	remove(fname);
225	1.96k	return 0;
226	88	exit:
227	88	gzclose(file);
228	88	remove(fname);
229	88	return -1;
230	2.05k	}