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

Last change on this file since 1858 was 1858, checked in by Sam Hocevar, 13 years ago
  • Network destination port choosing with -p/--ports.
  • Renamed -p/--pick into -l/--list to avoid conflicts.
  • Property svn:keywords set to Id
File size: 5.8 KB
Line 
1/*
2 *  zzuf - general purpose fuzzer
3 *  Copyright (c) 2006-2007 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: fuzz.c 1858 2007-11-02 22:45:54Z 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#include "ranges.h"
36
37#define MAGIC1 0x33ea84f7
38#define MAGIC2 0x783bc31f
39
40/* Fuzzing mode */
41static enum fuzzing
42{
43    FUZZING_XOR = 0, FUZZING_SET, FUZZING_UNSET
44}
45fuzzing;
46
47/* Per-offset byte protection */
48static int *ranges = NULL;
49static int static_ranges[512];
50
51/* Per-value byte protection */
52static int protect[256];
53static int refuse[256];
54
55/* Local prototypes */
56static void readchars(int *, char const *);
57
58extern void _zz_fuzzing(char const *mode)
59{
60    if(!strcmp(mode, "xor"))
61        fuzzing = FUZZING_XOR;
62    else if(!strcmp(mode, "set"))
63        fuzzing = FUZZING_SET;
64    else if(!strcmp(mode, "unset"))
65        fuzzing = FUZZING_UNSET;
66}
67
68void _zz_bytes(char const *list)
69{
70    /* TODO: free(ranges) if ranges != static_ranges */
71    ranges = _zz_allocrange(list, static_ranges);
72}
73
74void _zz_protect(char const *list)
75{
76    readchars(protect, list);
77}
78
79void _zz_refuse(char const *list)
80{
81    readchars(refuse, list);
82}
83
84void _zz_fuzz(int fd, volatile uint8_t *buf, int64_t len)
85{
86    int64_t start, stop;
87    int64_t pos = _zz_getpos(fd);
88    struct fuzz *fuzz;
89    volatile uint8_t *aligned_buf;
90    int64_t i, j;
91    int todo;
92
93#if 0
94    debug("fuzz(%i, %lli@%lli)", fd, (long long int)len,
95          (long long int)pos);
96#endif
97
98    aligned_buf = buf - pos;
99    fuzz = _zz_getfuzz(fd);
100
101    for(i = pos / CHUNKBYTES;
102        i < (pos + len + CHUNKBYTES - 1) / CHUNKBYTES;
103        i++)
104    {
105        /* Cache bitmask array */
106        if(fuzz->cur != (int)i)
107        {
108            uint32_t chunkseed = ((int)i + (int)(fuzz->ratio * MAGIC1)) ^ MAGIC2;
109            _zz_srand(fuzz->seed ^ chunkseed);
110
111            memset(fuzz->data, 0, CHUNKBYTES);
112
113            /* Add some random dithering to handle ratio < 1.0/CHUNKBYTES */
114            todo = (int)((fuzz->ratio * (8 * CHUNKBYTES * 1000)
115                                             + _zz_rand(1000)) / 1000.0);
116            while(todo--)
117            {
118                unsigned int idx = _zz_rand(CHUNKBYTES);
119                uint8_t bit = (1 << _zz_rand(8));
120
121                fuzz->data[idx] ^= bit;
122            }
123
124            fuzz->cur = i;
125        }
126
127        /* Apply our bitmask array to the buffer */
128        start = (i * CHUNKBYTES > pos) ? i * CHUNKBYTES : pos;
129
130        stop = ((i + 1) * CHUNKBYTES < pos + len)
131              ? (i + 1) * CHUNKBYTES : pos + len;
132
133        for(j = start; j < stop; j++)
134        {
135            uint8_t byte, fuzzbyte;
136
137            if(ranges && !_zz_isinrange(j, ranges))
138                continue; /* Not in one of the ranges, skip byte */
139
140            byte = aligned_buf[j];
141
142            if(protect[byte])
143                continue;
144
145            fuzzbyte = fuzz->data[j % CHUNKBYTES];
146
147            if(!fuzzbyte)
148                continue;
149
150            switch(fuzzing)
151            {
152            case FUZZING_XOR:
153                byte ^= fuzzbyte;
154                break;
155            case FUZZING_SET:
156                byte |= fuzzbyte;
157                break;
158            case FUZZING_UNSET:
159                byte &= ~fuzzbyte;
160                break;
161            }
162
163            if(refuse[byte])
164                continue;
165
166            aligned_buf[j] = byte;
167        }
168    }
169
170    /* Handle ungetc() */
171    if(fuzz->uflag)
172    {
173        fuzz->uflag = 0;
174        if(fuzz->upos == pos)
175            buf[0] = fuzz->uchar;
176    }
177}
178
179static void readchars(int *table, char const *list)
180{
181    static char const hex[] = "0123456789abcdef0123456789ABCDEF";
182    char const *tmp;
183    int a, b;
184
185    memset(table, 0, 256 * sizeof(int));
186
187    for(tmp = list, a = b = -1; *tmp; tmp++)
188    {
189        int new;
190
191        if(*tmp == '\\' && tmp[1] == '\0')
192            new = '\\';
193        else if(*tmp == '\\')
194        {
195            tmp++;
196            if(*tmp == 'n')
197                new = '\n';
198            else if(*tmp == 'r')
199                new = '\r';
200            else if(*tmp == 't')
201                new = '\t';
202            else if(tmp[0] >= '0' && tmp[0] <= '7' && tmp[1] >= '0'
203                     && tmp[1] <= '7' && tmp[2] >= '0' && tmp[2] <= '7')
204            {
205                new = tmp[2] - '0';
206                new |= (int)(tmp[1] - '0') << 3;
207                new |= (int)(tmp[0] - '0') << 6;
208                tmp += 2;
209            }
210            else if((*tmp == 'x' || *tmp == 'X')
211                     && tmp[1] && strchr(hex, tmp[1])
212                     && tmp[2] && strchr(hex, tmp[2]))
213            {
214                new = ((int)(strchr(hex, tmp[1]) - hex) & 0xf) << 4;
215                new |= (int)(strchr(hex, tmp[2]) - hex) & 0xf;
216                tmp += 2;
217            }
218            else
219                new = (unsigned char)*tmp; /* XXX: OK for \\, but what else? */
220        }
221        else
222            new = (unsigned char)*tmp;
223
224        if(a != -1 && b == '-' && a <= new)
225        {
226            while(a <= new)
227                table[a++] = 1;
228            a = b = -1;
229        }
230        else
231        {
232            if(a != -1)
233                table[a] = 1;
234            a = b;
235            b = new;
236        }
237    }
238
239    if(a != -1)
240        table[a] = 1;
241    if(b != -1)
242        table[b] = 1;
243}
244
Note: See TracBrowser for help on using the repository browser.