Always define enum long names so that cross-file references work.
[apps/agl-service-can-low-level.git] / tests / fuzztest / fuzztest.c
1 /* Fuzz testing for the nanopb core.
2  * Attempts to verify all the properties defined in the security model document.
3  */
4
5 #include <pb_decode.h>
6 #include <pb_encode.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <assert.h>
11 #include <time.h>
12 #include <malloc_wrappers.h>
13 #include "alltypes_static.pb.h"
14 #include "alltypes_pointer.pb.h"
15
16 static uint64_t random_seed;
17
18 /* Uses xorshift64 here instead of rand() for both speed and
19  * reproducibility across platforms. */
20 static uint32_t rand_word()
21 {
22     random_seed ^= random_seed >> 12;
23     random_seed ^= random_seed << 25;
24     random_seed ^= random_seed >> 27;
25     return random_seed * 2685821657736338717ULL;
26 }
27
28 /* Get a random integer in range, with approximately flat distribution. */
29 static int rand_int(int min, int max)
30 {
31     return rand_word() % (max + 1 - min) + min;
32 }
33
34 static bool rand_bool()
35 {
36     return rand_word() & 1;
37 }
38
39 /* Get a random byte, with skewed distribution.
40  * Important corner cases like 0xFF, 0x00 and 0xFE occur more
41  * often than other values. */
42 static uint8_t rand_byte()
43 {
44     uint32_t w = rand_word();
45     uint8_t b = w & 0xFF;
46     if (w & 0x100000)
47         b >>= (w >> 8) & 7;
48     if (w & 0x200000)
49         b <<= (w >> 12) & 7;
50     if (w & 0x400000)
51         b ^= 0xFF;
52     return b;
53 }
54
55 /* Get a random length, with skewed distribution.
56  * Favors the shorter lengths, but always atleast 1. */
57 static size_t rand_len(size_t max)
58 {
59     uint32_t w = rand_word();
60     size_t s;
61     if (w & 0x800000)
62         w &= 3;
63     else if (w & 0x400000)
64         w &= 15;
65     else if (w & 0x200000)
66         w &= 255;
67
68     s = (w % max);
69     if (s == 0)
70         s = 1;
71     
72     return s;
73 }
74
75 /* Fills a buffer with random data with skewed distribution. */
76 static void rand_fill(uint8_t *buf, size_t count)
77 {
78     while (count--)
79         *buf++ = rand_byte();
80 }
81
82 /* Fill with random protobuf-like data */
83 static size_t rand_fill_protobuf(uint8_t *buf, size_t min_bytes, size_t max_bytes, int min_tag)
84 {
85     pb_ostream_t stream = pb_ostream_from_buffer(buf, max_bytes);
86
87     while(stream.bytes_written < min_bytes)
88     {
89         pb_wire_type_t wt = rand_int(0, 3);
90         if (wt == 3) wt = 5; /* Gap in values */
91         
92         if (!pb_encode_tag(&stream, wt, rand_int(min_tag, min_tag + 512)))
93             break;
94     
95         if (wt == PB_WT_VARINT)
96         {
97             uint64_t value;
98             rand_fill((uint8_t*)&value, sizeof(value));
99             pb_encode_varint(&stream, value);
100         }
101         else if (wt == PB_WT_64BIT)
102         {
103             uint64_t value;
104             rand_fill((uint8_t*)&value, sizeof(value));
105             pb_encode_fixed64(&stream, &value);
106         }
107         else if (wt == PB_WT_32BIT)
108         {
109             uint32_t value;
110             rand_fill((uint8_t*)&value, sizeof(value));
111             pb_encode_fixed32(&stream, &value);
112         }
113         else if (wt == PB_WT_STRING)
114         {
115             size_t len;
116             uint8_t *buf;
117             
118             if (min_bytes > stream.bytes_written)
119                 len = rand_len(min_bytes - stream.bytes_written);
120             else
121                 len = 0;
122             
123             buf = malloc(len);
124             pb_encode_varint(&stream, len);
125             rand_fill(buf, len);
126             pb_write(&stream, buf, len);
127             free(buf);
128         }
129     }
130     
131     return stream.bytes_written;
132 }
133
134 /* Given a buffer of data, mess it up a bit */
135 static void rand_mess(uint8_t *buf, size_t count)
136 {
137     int m = rand_int(0, 3);
138     
139     if (m == 0)
140     {
141         /* Replace random substring */
142         int s = rand_int(0, count - 1);
143         int l = rand_len(count - s);
144         rand_fill(buf + s, l);
145     }
146     else if (m == 1)
147     {
148         /* Swap random bytes */
149         int a = rand_int(0, count - 1);
150         int b = rand_int(0, count - 1);
151         int x = buf[a];
152         buf[a] = buf[b];
153         buf[b] = x;
154     }
155     else if (m == 2)
156     {
157         /* Duplicate substring */
158         int s = rand_int(0, count - 2);
159         int l = rand_len((count - s) / 2);
160         memcpy(buf + s + l, buf + s, l);
161     }
162     else if (m == 3)
163     {
164         /* Add random protobuf noise */
165         int s = rand_int(0, count - 1);
166         int l = rand_len(count - s);
167         rand_fill_protobuf(buf + s, l, count - s, 1);
168     }
169 }
170
171 /* Some default data to put in the message */
172 static const alltypes_static_AllTypes initval = alltypes_static_AllTypes_init_default;
173
174 #define BUFSIZE 4096
175
176 static bool do_static_encode(uint8_t *buffer, size_t *msglen)
177 {
178     pb_ostream_t stream;
179     bool status;
180
181     /* Allocate a message and fill it with defaults */
182     alltypes_static_AllTypes *msg = malloc_with_check(sizeof(alltypes_static_AllTypes));
183     memcpy(msg, &initval, sizeof(initval));
184
185     /* Apply randomness to the data before encoding */
186     while (rand_int(0, 7))
187         rand_mess((uint8_t*)msg, sizeof(alltypes_static_AllTypes));
188
189     stream = pb_ostream_from_buffer(buffer, BUFSIZE);
190     status = pb_encode(&stream, alltypes_static_AllTypes_fields, msg);
191     assert(stream.bytes_written <= BUFSIZE);
192     assert(stream.bytes_written <= alltypes_static_AllTypes_size);
193     
194     *msglen = stream.bytes_written;
195     free_with_check(msg);
196     
197     return status;
198 }
199
200 /* Append or prepend protobuf noise */
201 static void do_protobuf_noise(uint8_t *buffer, size_t *msglen)
202 {
203     int m = rand_int(0, 2);
204     size_t max_size = BUFSIZE - 32 - *msglen;
205     if (m == 1)
206     {
207         /* Prepend */
208         uint8_t *tmp = malloc_with_check(BUFSIZE);
209         size_t s = rand_fill_protobuf(tmp, rand_len(max_size), BUFSIZE - *msglen, 512);
210         memmove(buffer + s, buffer, *msglen);
211         memcpy(buffer, tmp, s);
212         free_with_check(tmp);
213         *msglen += s;
214     }
215     else if (m == 2)
216     {
217         /* Append */
218         size_t s = rand_fill_protobuf(buffer + *msglen, rand_len(max_size), BUFSIZE - *msglen, 512);
219         *msglen += s;
220     }
221 }
222
223 static bool do_static_decode(uint8_t *buffer, size_t msglen, bool assert_success)
224 {
225     pb_istream_t stream;
226     bool status;
227     
228     alltypes_static_AllTypes *msg = malloc_with_check(sizeof(alltypes_static_AllTypes));
229     rand_fill((uint8_t*)msg, sizeof(alltypes_static_AllTypes));
230     stream = pb_istream_from_buffer(buffer, msglen);
231     status = pb_decode(&stream, alltypes_static_AllTypes_fields, msg);
232     
233     if (!status && assert_success)
234     {
235         /* Anything that was successfully encoded, should be decodeable.
236          * One exception: strings without null terminator are encoded up
237          * to end of buffer, but refused on decode because the terminator
238          * would not fit. */
239         if (strcmp(stream.errmsg, "string overflow") != 0)
240             assert(status);
241     }
242     
243     free_with_check(msg);
244     return status;
245 }
246
247 static bool do_pointer_decode(uint8_t *buffer, size_t msglen, bool assert_success)
248 {
249     pb_istream_t stream;
250     bool status;
251     alltypes_pointer_AllTypes *msg;
252     
253     msg = malloc_with_check(sizeof(alltypes_pointer_AllTypes));
254     memset(msg, 0, sizeof(alltypes_pointer_AllTypes));
255     stream = pb_istream_from_buffer(buffer, msglen);
256
257     assert(get_alloc_count() == 0);
258     status = pb_decode(&stream, alltypes_pointer_AllTypes_fields, msg);
259     
260     if (assert_success)
261         assert(status);
262     
263     pb_release(alltypes_pointer_AllTypes_fields, msg);    
264     assert(get_alloc_count() == 0);
265     
266     free_with_check(msg);
267
268     return status;
269 }
270
271 /* Do a decode -> encode -> decode -> encode roundtrip */
272 static void do_static_roundtrip(uint8_t *buffer, size_t msglen)
273 {
274     bool status;
275     uint8_t *buf2 = malloc_with_check(BUFSIZE);
276     uint8_t *buf3 = malloc_with_check(BUFSIZE);
277     size_t msglen2, msglen3;
278     alltypes_static_AllTypes *msg1 = malloc_with_check(sizeof(alltypes_static_AllTypes));
279     alltypes_static_AllTypes *msg2 = malloc_with_check(sizeof(alltypes_static_AllTypes));
280     memset(msg1, 0, sizeof(alltypes_static_AllTypes));
281     memset(msg2, 0, sizeof(alltypes_static_AllTypes));
282     
283     {
284         pb_istream_t stream = pb_istream_from_buffer(buffer, msglen);
285         status = pb_decode(&stream, alltypes_static_AllTypes_fields, msg1);
286         assert(status);
287     }
288     
289     {
290         pb_ostream_t stream = pb_ostream_from_buffer(buf2, BUFSIZE);
291         status = pb_encode(&stream, alltypes_static_AllTypes_fields, msg1);
292         assert(status);
293         msglen2 = stream.bytes_written;
294     }
295     
296     {
297         pb_istream_t stream = pb_istream_from_buffer(buf2, msglen2);
298         status = pb_decode(&stream, alltypes_static_AllTypes_fields, msg2);
299         assert(status);
300     }
301     
302     {
303         pb_ostream_t stream = pb_ostream_from_buffer(buf3, BUFSIZE);
304         status = pb_encode(&stream, alltypes_static_AllTypes_fields, msg2);
305         assert(status);
306         msglen3 = stream.bytes_written;
307     }
308     
309     assert(msglen2 == msglen3);
310     assert(memcmp(buf2, buf3, msglen2) == 0);
311     
312     free_with_check(msg1);
313     free_with_check(msg2);
314     free_with_check(buf2);
315     free_with_check(buf3);
316 }
317
318 /* Do decode -> encode -> decode -> encode roundtrip */
319 static void do_pointer_roundtrip(uint8_t *buffer, size_t msglen)
320 {
321     bool status;
322     uint8_t *buf2 = malloc_with_check(BUFSIZE);
323     uint8_t *buf3 = malloc_with_check(BUFSIZE);
324     size_t msglen2, msglen3;
325     alltypes_pointer_AllTypes *msg1 = malloc_with_check(sizeof(alltypes_pointer_AllTypes));
326     alltypes_pointer_AllTypes *msg2 = malloc_with_check(sizeof(alltypes_pointer_AllTypes));
327     memset(msg1, 0, sizeof(alltypes_pointer_AllTypes));
328     memset(msg2, 0, sizeof(alltypes_pointer_AllTypes));
329     
330     {
331         pb_istream_t stream = pb_istream_from_buffer(buffer, msglen);
332         status = pb_decode(&stream, alltypes_pointer_AllTypes_fields, msg1);
333         assert(status);
334     }
335     
336     {
337         pb_ostream_t stream = pb_ostream_from_buffer(buf2, BUFSIZE);
338         status = pb_encode(&stream, alltypes_pointer_AllTypes_fields, msg1);
339         assert(status);
340         msglen2 = stream.bytes_written;
341     }
342     
343     {
344         pb_istream_t stream = pb_istream_from_buffer(buf2, msglen2);
345         status = pb_decode(&stream, alltypes_pointer_AllTypes_fields, msg2);
346         assert(status);
347     }
348     
349     {
350         pb_ostream_t stream = pb_ostream_from_buffer(buf3, BUFSIZE);
351         status = pb_encode(&stream, alltypes_pointer_AllTypes_fields, msg2);
352         assert(status);
353         msglen3 = stream.bytes_written;
354     }
355     
356     assert(msglen2 == msglen3);
357     assert(memcmp(buf2, buf3, msglen2) == 0);
358     
359     pb_release(alltypes_pointer_AllTypes_fields, msg1);
360     pb_release(alltypes_pointer_AllTypes_fields, msg2);
361     free_with_check(msg1);
362     free_with_check(msg2);
363     free_with_check(buf2);
364     free_with_check(buf3);
365 }
366
367 static void run_iteration()
368 {
369     uint8_t *buffer = malloc_with_check(BUFSIZE);
370     size_t msglen;
371     bool status;
372     
373     rand_fill(buffer, BUFSIZE);
374
375     if (do_static_encode(buffer, &msglen))
376     {
377         do_protobuf_noise(buffer, &msglen);
378     
379         status = do_static_decode(buffer, msglen, true);
380         
381         if (status)
382             do_static_roundtrip(buffer, msglen);
383         
384         status = do_pointer_decode(buffer, msglen, true);
385         
386         if (status)
387             do_pointer_roundtrip(buffer, msglen);
388         
389         /* Apply randomness to the encoded data */
390         while (rand_bool())
391             rand_mess(buffer, BUFSIZE);
392         
393         /* Apply randomness to encoded data length */
394         if (rand_bool())
395             msglen = rand_int(0, BUFSIZE);
396         
397         status = do_static_decode(buffer, msglen, false);
398         do_pointer_decode(buffer, msglen, status);
399         
400         if (status)
401         {
402             do_static_roundtrip(buffer, msglen);
403             do_pointer_roundtrip(buffer, msglen);
404         }
405     }
406     
407     free_with_check(buffer);
408 }
409
410 int main(int argc, char **argv)
411 {
412     int i;
413     if (argc > 1)
414     {
415         random_seed = atol(argv[1]);
416     }
417     else
418     {
419         random_seed = time(NULL);
420     }
421     
422     fprintf(stderr, "Random seed: %llu\n", (long long unsigned)random_seed);
423     
424     for (i = 0; i < 10000; i++)
425     {
426         run_iteration();
427     }
428     
429     return 0;
430 }
431