source: zzuf/trunk/src/fuzz.c @ 1736

Last change on this file since 1736 was 1736, checked in by Sam Hocevar, 16 years ago
  • Fixed more MSVC compilation warnings.
  • Property svn:keywords set to Id
File size: 6.7 KB
Line 
1/*
2 *  zzuf - general purpose fuzzer
3 *  Copyright (c) 2006 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: fuzz.c 1736 2007-02-02 11:58:06Z sam $
7 *
8 *  This program is free software. It comes without any warranty, to
9 *  the extent permitted by applicable law. You can redistribute it
10 *  and/or modify it under the terms of the Do What The Fuck You Want
11 *  To Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 *  fuzz.c: fuzz functions
17 */
18
19#include "config.h"
20
21#if defined HAVE_STDINT_H
22#   include <stdint.h>
23#elif defined HAVE_INTTYPES_H
24#   include <inttypes.h>
25#endif
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29
30#include "libzzuf.h"
31#include "debug.h"
32#include "random.h"
33#include "fuzz.h"
34#include "fd.h"
35
36#define MAGIC1 0x33ea84f7
37#define MAGIC2 0x783bc31f
38
39/* Fuzzing mode */
40static enum fuzzing
41{
42    FUZZING_XOR = 0, FUZZING_SET, FUZZING_UNSET
43}
44fuzzing;
45
46/* Per-offset byte protection */
47static int *ranges = NULL;
48static int ranges_static[512];
49
50/* Per-value byte protection */
51static int protect[256];
52static int refuse[256];
53
54/* Local prototypes */
55static void readchars(int *, char const *);
56
57extern void _zz_fuzzing(char const *mode)
58{
59    if(!strcmp(mode, "xor"))
60        fuzzing = FUZZING_XOR;
61    else if(!strcmp(mode, "set"))
62        fuzzing = FUZZING_SET;
63    else if(!strcmp(mode, "unset"))
64        fuzzing = FUZZING_UNSET;
65}
66
67void _zz_bytes(char const *list)
68{
69    char const *parser;
70    unsigned int i, chunks;
71
72    /* Count commas */
73    for(parser = list, chunks = 1; *parser; parser++)
74        if(*parser == ',')
75            chunks++;
76
77    /* TODO: free(ranges) if ranges != ranges_static */
78    if(chunks >= 256)
79        ranges = malloc((chunks + 1) * 2 * sizeof(unsigned int));
80    else
81        ranges = ranges_static;
82
83    /* Fill ranges list */
84    for(parser = list, i = 0; i < chunks; i++)
85    {
86        char const *comma = strchr(parser, ',');
87        char const *dash = strchr(parser, '-');
88
89        ranges[i * 2] = (dash == parser) ? 0 : atoi(parser);
90        if(dash && (dash + 1 == comma || dash[1] == '\0'))
91            ranges[i * 2 + 1] = ranges[i * 2]; /* special case */
92        else if(dash && (!comma || dash < comma))
93            ranges[i * 2 + 1] = atoi(dash + 1) + 1;
94        else
95            ranges[i * 2 + 1] = ranges[i * 2] + 1;
96        parser = comma + 1;
97    }
98
99    ranges[i * 2] = ranges[i * 2 + 1] = 0;
100}
101
102void _zz_protect(char const *list)
103{
104    readchars(protect, list);
105}
106
107void _zz_refuse(char const *list)
108{
109    readchars(refuse, list);
110}
111
112void _zz_fuzz(int fd, volatile uint8_t *buf, int64_t len)
113{
114    int64_t start, stop;
115    int64_t pos = _zz_getpos(fd);
116    struct fuzz *fuzz;
117    volatile uint8_t *aligned_buf;
118    int64_t i, j;
119    int todo;
120
121#if 0
122    debug("fuzz(%i, %lli@%lli)", fd, (long long int)len,
123          (long long int)pos);
124#endif
125
126    aligned_buf = buf - pos;
127    fuzz = _zz_getfuzz(fd);
128
129    for(i = pos / CHUNKBYTES;
130        i < (pos + len + CHUNKBYTES - 1) / CHUNKBYTES;
131        i++)
132    {
133        /* Cache bitmask array */
134        if(fuzz->cur != (int)i)
135        {
136            uint32_t chunkseed = ((int)i + (int)(fuzz->ratio * MAGIC1)) ^ MAGIC2;
137            _zz_srand(fuzz->seed ^ chunkseed);
138
139            memset(fuzz->data, 0, CHUNKBYTES);
140
141            /* Add some random dithering to handle ratio < 1.0/CHUNKBYTES */
142            todo = (int)((fuzz->ratio * (8 * CHUNKBYTES * 1000)
143                                             + _zz_rand(1000)) / 1000.0);
144            while(todo--)
145            {
146                unsigned int idx = _zz_rand(CHUNKBYTES);
147                uint8_t bit = (1 << _zz_rand(8));
148
149                fuzz->data[idx] ^= bit;
150            }
151
152            fuzz->cur = i;
153        }
154
155        /* Apply our bitmask array to the buffer */
156        start = (i * CHUNKBYTES > pos) ? i * CHUNKBYTES : pos;
157
158        stop = ((i + 1) * CHUNKBYTES < pos + len)
159              ? (i + 1) * CHUNKBYTES : pos + len;
160
161        for(j = start; j < stop; j++)
162        {
163            int *r;
164            uint8_t byte, fuzzbyte;
165
166            if(!ranges)
167                goto range_ok;
168
169            for(r = ranges; r[1]; r += 2)
170                if(j >= r[0] && (r[0] == r[1] || j < r[1]))
171                    goto range_ok;
172
173            continue; /* Not in one of the ranges, skip byte */
174
175        range_ok:
176            byte = aligned_buf[j];
177
178            if(protect[byte])
179                continue;
180
181            fuzzbyte = fuzz->data[j % CHUNKBYTES];
182
183            if(!fuzzbyte)
184                continue;
185
186            switch(fuzzing)
187            {
188            case FUZZING_XOR:
189                byte ^= fuzzbyte;
190                break;
191            case FUZZING_SET:
192                byte |= fuzzbyte;
193                break;
194            case FUZZING_UNSET:
195                byte &= ~fuzzbyte;
196                break;
197            }
198
199            if(refuse[byte])
200                continue;
201
202            aligned_buf[j] = byte;
203        }
204    }
205
206    /* Handle ungetc() */
207    if(fuzz->uflag)
208    {
209        fuzz->uflag = 0;
210        if(fuzz->upos == pos)
211            buf[0] = fuzz->uchar;
212    }
213}
214
215static void readchars(int *table, char const *list)
216{
217    static char const hex[] = "0123456789abcdef0123456789ABCDEF";
218    char const *tmp;
219    int a, b;
220
221    memset(table, 0, 256 * sizeof(int));
222
223    for(tmp = list, a = b = -1; *tmp; tmp++)
224    {
225        int new;
226
227        if(*tmp == '\\' && tmp[1] == '\0')
228            new = '\\';
229        else if(*tmp == '\\')
230        {
231            tmp++;
232            if(*tmp == 'n')
233                new = '\n';
234            else if(*tmp == 'r')
235                new = '\r';
236            else if(*tmp == 't')
237                new = '\t';
238            else if(tmp[0] >= '0' && tmp[0] <= '7' && tmp[1] >= '0'
239                     && tmp[1] <= '7' && tmp[2] >= '0' && tmp[2] <= '7')
240            {
241                new = tmp[2] - '0';
242                new |= (int)(tmp[1] - '0') << 3;
243                new |= (int)(tmp[0] - '0') << 6;
244                tmp += 2;
245            }
246            else if((*tmp == 'x' || *tmp == 'X')
247                     && tmp[1] && strchr(hex, tmp[1])
248                     && tmp[2] && strchr(hex, tmp[2]))
249            {
250                new = ((int)(strchr(hex, tmp[1]) - hex) & 0xf) << 4;
251                new |= (int)(strchr(hex, tmp[2]) - hex) & 0xf;
252                tmp += 2;
253            }
254            else
255                new = (unsigned char)*tmp; /* XXX: OK for \\, but what else? */
256        }
257        else
258            new = (unsigned char)*tmp;
259
260        if(a != -1 && b == '-' && a <= new)
261        {
262            while(a <= new)
263                table[a++] = 1;
264            a = b = -1;
265        }
266        else
267        {
268            if(a != -1)
269                table[a] = 1;
270            a = b;
271            b = new;
272        }
273    }
274
275    if(a != -1)
276        table[a] = 1;
277    if(b != -1)
278        table[b] = 1;
279}
280
Note: See TracBrowser for help on using the repository browser.