/* american fuzzy lop++ - GCC plugin instrumentation bootstrap --------------------------------------------------------- Written by Austin Seipp and Laszlo Szekeres and Michal Zalewski GCC integration design is based on the LLVM design, which comes from Laszlo Szekeres. 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 This code is the rewrite of afl-as.h's main_payload. */ #ifdef __ANDROID__ #include "android-ashmem.h" #endif #include "../config.h" #include "../types.h" #ifdef USEMMAP #include #endif #include #include #include #include #include #include #include #include #include #include #include /* Globals needed by the injected instrumentation. The __afl_area_initial region is used for instrumentation output before __afl_map_shm() has a chance to run. It will end up as .comm, so it shouldn't be too wasteful. */ u8 __afl_area_initial[MAP_SIZE]; u8 *__afl_area_ptr = __afl_area_initial; #ifdef __ANDROID__ u32 __afl_prev_loc; u32 __afl_final_loc; #else __thread u32 __afl_prev_loc; __thread u32 __afl_final_loc; #endif /* Trace a basic block with some ID */ void __afl_trace(const u32 x) { #if 1 /* enable for neverZero feature. */ __afl_area_ptr[__afl_prev_loc ^ x] += 1 + ((u8)(1 + __afl_area_ptr[__afl_prev_loc ^ x]) == 0); #else ++__afl_area_ptr[__afl_prev_loc ^ x]; #endif __afl_prev_loc = (x >> 1); return; } /* Running in persistent mode? */ static u8 is_persistent; /* SHM setup. */ static void __afl_map_shm(void) { u8 *id_str = getenv(SHM_ENV_VAR); /* If we're running under AFL, attach to the appropriate region, replacing the early-stage __afl_area_initial region that is needed to allow some really hacky .init code to work correctly in projects such as OpenSSL. */ if (id_str) { #ifdef USEMMAP const char * shm_file_path = id_str; int shm_fd = -1; unsigned char *shm_base = NULL; /* create the shared memory segment as if it was a file */ shm_fd = shm_open(shm_file_path, O_RDWR, 0600); if (shm_fd == -1) { fprintf(stderr, "shm_open() failed\n"); exit(1); } /* map the shared memory segment to the address space of the process */ shm_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0); if (shm_base == MAP_FAILED) { close(shm_fd); shm_fd = -1; fprintf(stderr, "mmap() failed\n"); exit(2); } __afl_area_ptr = shm_base; #else u32 shm_id = atoi(id_str); __afl_area_ptr = shmat(shm_id, NULL, 0); #endif /* Whooooops. */ if (__afl_area_ptr == (void *)-1) exit(1); /* Write something into the bitmap so that even with low AFL_INST_RATIO, our parent doesn't give up on us. */ __afl_area_ptr[0] = 1; } } /* Fork server logic. */ static void __afl_start_forkserver(void) { u8 tmp[4] = {0, 0, 0, 0}; u32 map_size = MAP_SIZE; s32 child_pid; u8 child_stopped = 0; void (*old_sigchld_handler)(int) = signal(SIGCHLD, SIG_DFL); /* Phone home and tell the parent that we're OK. If parent isn't there, assume we're not running in forkserver mode and just execute program. */ if (MAP_SIZE <= 0x800000) { map_size = (FS_OPT_ENABLED | FS_OPT_MAPSIZE | FS_OPT_SET_MAPSIZE(MAP_SIZE)); memcpy(tmp, &map_size, 4); } if (write(FORKSRV_FD + 1, tmp, 4) != 4) return; while (1) { u32 was_killed; int status; /* Wait for parent by reading from the pipe. Abort if read fails. */ if (read(FORKSRV_FD, &was_killed, 4) != 4) exit(1); /* If we stopped the child in persistent mode, but there was a race condition and afl-fuzz already issued SIGKILL, write off the old process. */ if (child_stopped && was_killed) { child_stopped = 0; if (waitpid(child_pid, &status, 0) < 0) exit(1); } if (!child_stopped) { /* Once woken up, create a clone of our process. */ child_pid = fork(); if (child_pid < 0) exit(1); /* In child process: close fds, resume execution. */ if (!child_pid) { signal(SIGCHLD, old_sigchld_handler); close(FORKSRV_FD); close(FORKSRV_FD + 1); return; } } else { /* Special handling for persistent mode: if the child is alive but currently stopped, simply restart it with SIGCONT. */ kill(child_pid, SIGCONT); child_stopped = 0; } /* In parent process: write PID to pipe, then wait for child. */ if (write(FORKSRV_FD + 1, &child_pid, 4) != 4) exit(1); if (waitpid(child_pid, &status, is_persistent ? WUNTRACED : 0) < 0) exit(1); /* In persistent mode, the child stops itself with SIGSTOP to indicate a successful run. In this case, we want to wake it up without forking again. */ if (WIFSTOPPED(status)) child_stopped = 1; /* Relay wait status to pipe, then loop back. */ if (write(FORKSRV_FD + 1, &status, 4) != 4) exit(1); } } /* A simplified persistent mode handler, used as explained in README.md. */ int __afl_persistent_loop(unsigned int max_cnt) { static u8 first_pass = 1; static u32 cycle_cnt; if (first_pass) { /* Make sure that every iteration of __AFL_LOOP() starts with a clean slate. On subsequent calls, the parent will take care of that, but on the first iteration, it's our job to erase any trace of whatever happened before the loop. */ if (is_persistent) { memset(__afl_area_ptr, 0, MAP_SIZE); __afl_area_ptr[0] = 1; __afl_prev_loc = 0; } cycle_cnt = max_cnt; first_pass = 0; return 1; } if (is_persistent) { if (--cycle_cnt) { raise(SIGSTOP); __afl_area_ptr[0] = 1; __afl_prev_loc = 0; return 1; } else { /* When exiting __AFL_LOOP(), make sure that the subsequent code that follows the loop is not traced. We do that by pivoting back to the dummy output region. */ __afl_area_ptr = __afl_area_initial; } } return 0; } /* This one can be called from user code when deferred forkserver mode is enabled. */ void __afl_manual_init(void) { static u8 init_done; if (!init_done) { __afl_map_shm(); __afl_start_forkserver(); init_done = 1; } } /* Proper initialization routine. */ __attribute__((constructor(101))) void __afl_auto_init(void) { is_persistent = !!getenv(PERSIST_ENV_VAR); if (getenv(DEFER_ENV_VAR)) return; __afl_manual_init(); }