Line data    Source code

       1             : /** Definitions of nd() functions for fuzzing */
       2             : 
       3             : #include <assert.h>
       4             : #include <stdbool.h>
       5             : #include <stdint.h>
       6             : #include <stdio.h>
       7             : #include <string.h>
       8             : 
       9             : #include <setjmp.h>
      10             : 
      11             : /** Global access to fuzz data */
      12             : uint8_t *g_fuzz_data;
      13             : size_t g_fuzz_data_size;
      14             : uint8_t *g_fuzz_data_iterator;
      15             : 
      16             : /** jmp environment */
      17             : jmp_buf g_jmp_buf;
      18             : 
      19             : #define UPDATE_FUZZ_ITERATOR(TYPE)                                             \
      20    64024575 :   if (g_fuzz_data_iterator + sizeof(TYPE) - g_fuzz_data >= g_fuzz_data_size) { \
      21     2068591 :     longjmp(g_jmp_buf, 1);                                             \
      22     2068591 :   }
      23             : 
      24    10208048 : bool nd_bool(void) {
      25    10208048 :   bool res;
      26    10208048 : 
      27    10208048 :   UPDATE_FUZZ_ITERATOR(bool)
      28    10208048 :   memcpy(&res, g_fuzz_data_iterator, sizeof(bool));
      29    10146824 :   g_fuzz_data_iterator += sizeof(bool);
      30    10146824 : 
      31    10146824 :   return res;
      32    10208048 : }
      33             : 
      34      471681 : int nd_int(void) {
      35      471681 :   int res;
      36      471681 : 
      37      471681 :   UPDATE_FUZZ_ITERATOR(int);
      38      462514 :   memcpy(&res, g_fuzz_data_iterator, sizeof(int));
      39      462514 :   g_fuzz_data_iterator += sizeof(int);
      40      462514 : 
      41      462514 :   return res;
      42      471681 : }
      43             : 
      44     2186908 : uint8_t nd_uint8_t(void) {
      45     2186908 :   uint8_t res;
      46     2186908 : 
      47     2186908 :   UPDATE_FUZZ_ITERATOR(uint8_t);
      48     2142269 :   memcpy(&res, g_fuzz_data_iterator, sizeof(uint8_t));
      49     2142269 :   g_fuzz_data_iterator += sizeof(uint8_t);
      50     2142269 : 
      51     2142269 :   return res;
      52     2186908 : }
      53             : 
      54      143152 : uint16_t nd_uint16_t(void) {
      55      143152 :   uint16_t res;
      56      143152 : 
      57      143152 :   UPDATE_FUZZ_ITERATOR(uint16_t);
      58      140981 :   memcpy(&res, g_fuzz_data_iterator, sizeof(uint16_t));
      59      140981 :   g_fuzz_data_iterator += sizeof(uint16_t);
      60      140981 : 
      61      140981 :   return res;
      62      143152 : }
      63             : 
      64      400548 : uint32_t nd_uint32_t(void) {
      65      400548 :   uint32_t res;
      66      400548 : 
      67      400548 :   UPDATE_FUZZ_ITERATOR(uint32_t);
      68      388598 :   memcpy(&res, g_fuzz_data_iterator, sizeof(uint32_t));
      69      388598 :   g_fuzz_data_iterator += sizeof(uint32_t);
      70      388598 : 
      71      388598 :   return res;
      72      400548 : }
      73             : 
      74      821617 : uint64_t nd_uint64_t(void) {
      75      821617 :   uint64_t res;
      76      821617 : 
      77      821617 :   UPDATE_FUZZ_ITERATOR(uint64_t);
      78      774328 :   memcpy(&res, g_fuzz_data_iterator, sizeof(uint64_t));
      79      774328 :   g_fuzz_data_iterator += sizeof(uint64_t);
      80      774328 : 
      81      774328 :   return res;
      82      821617 : }
      83             : 
      84    48311768 : size_t nd_size_t(void) {
      85    48311768 :   size_t res;
      86    48311768 : 
      87    48311768 :   UPDATE_FUZZ_ITERATOR(size_t);
      88    46582440 :   memcpy(&res, g_fuzz_data_iterator, sizeof(size_t));
      89    46582440 :   g_fuzz_data_iterator += sizeof(size_t);
      90    46582440 : 
      91    46582440 :   return res;
      92    48311768 : }
      93             : 
      94     1480853 : void *nd_voidp(void) {
      95     1480853 :   void *res;
      96     1480853 : 
      97     1480853 :   UPDATE_FUZZ_ITERATOR(res);
      98     1318030 :   memcpy(&res, g_fuzz_data_iterator, sizeof(res));
      99     1318030 :   g_fuzz_data_iterator += sizeof(res);
     100     1318030 : 
     101     1318030 :   return res;
     102     1480853 : }
     103             : 
     104    10277709 : void memhavoc(void *ptr, size_t size) {
     105    10277709 :   if (!ptr) {
     106           0 :     return;
     107           0 :   }
     108    10277709 :   if (g_fuzz_data_iterator + size - g_fuzz_data >= g_fuzz_data_size) {
     109      544093 :     longjmp(g_jmp_buf, 1);
     110      544093 :   }
     111     9733616 : 
     112     9733616 :   memcpy(ptr, g_fuzz_data_iterator, size);
     113     9733616 :   g_fuzz_data_iterator += size;
     114     9733616 : }
     115             : 
     116           0 : void __VERIFIER_assert(bool v) {
     117           0 :   /* fprintf(stdout, "CHECK ASSERT\n"); */
     118           0 :   fflush(stdout);
     119           0 : 
     120           0 :   return assert(v);
     121           0 : }
     122             : 
     123    38015089 : void __SEA_assume(bool v) {
     124    38015089 :   // -- if assumption fails, jump back to LLVMFuzzerTestOneInput
     125    38015089 :   if (!v) {
     126    10883625 :     longjmp(g_jmp_buf, 1);
     127    10883625 :   }
     128    38015089 : }
     129             : 
     130    38015089 : void __VERIFIER_assume(int v) {
     131    38015089 :   __SEA_assume(v);
     132    38015089 : }
     133             : 
     134           0 : void __VERIFIER_error(void) {
     135           0 :   fprintf(stdout, "ERROR REACHED\n");
     136           0 :   fflush(stdout);
     137           0 :   assert(0);
     138           0 : }
     139             : 
     140             : /** expected entry of verification harness */
     141             : extern int _main(void);
     142             : 
     143    19550000 : int LLVMFuzzerTestOneInput(uint8_t *Data, size_t Size) {
     144    19550000 :   g_fuzz_data = Data;
     145    19550000 :   g_fuzz_data_size = Size;
     146    19550000 :   g_fuzz_data_iterator = g_fuzz_data;
     147    19550000 : 
     148    19550000 :   if (setjmp(g_jmp_buf)) {
     149    13496309 :     // assumption failed, abort
     150    13496309 :     return 0;
     151    13496309 :   }
     152     6053691 :   _main();
     153     6053691 : 
     154     6053691 :   return 0;
     155     6053691 : }
     156             : 
     157           0 : bool nd_malloc_is_fail(void) { return nd_bool(); }
     158             : 
     159           0 : int nondet_compare(const void* a, const void *b) {
     160           0 :   return nd_int();
     161           0 : }
     162             : 
     163             : /* nd_linked_list_node - special function for returning a symbolic value of
     164             :  * the linked list node pointer.
     165             : */
     166     1330853 : struct aws_linked_list_node *nd_linked_list_node(void) {
     167     1330853 :   return (struct aws_linked_list_node *)nd_voidp();
     168     1330853 : }