Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 1 | /* |
| 2 | |
| 3 | honggfuzz - cmdline parsing |
| 4 | |
| 5 | ----------------------------------------- |
| 6 | |
| 7 | Copyright 2014 Google Inc. All Rights Reserved. |
| 8 | |
| 9 | Licensed under the Apache License, Version 2.0 (the "License"); |
| 10 | you may not use this file except in compliance with the License. |
| 11 | You may obtain a copy of the License at |
| 12 | |
| 13 | http://www.apache.org/licenses/LICENSE-2.0 |
| 14 | |
| 15 | Unless required by applicable law or agreed to in writing, software |
| 16 | distributed under the License is distributed on an "AS IS" BASIS, |
| 17 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 18 | See the License for the specific language governing permissions and |
| 19 | limitations under the License. |
| 20 | |
| 21 | */ |
| 22 | |
| 23 | #include "cmdline.h" |
| 24 | |
| 25 | #include <ctype.h> |
| 26 | #include <errno.h> |
| 27 | #include <getopt.h> |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 28 | #include <inttypes.h> |
| 29 | #include <limits.h> |
Robert Swiecki | 846ccd7 | 2017-01-12 17:52:23 +0100 | [diff] [blame] | 30 | #if defined(_HF_ARCH_LINUX) |
| 31 | #include <sched.h> |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 32 | #endif /* defined(_HF_ARCH_LINUX) */ |
Robert Swiecki | 846ccd7 | 2017-01-12 17:52:23 +0100 | [diff] [blame] | 33 | #include <signal.h> |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 34 | #include <stdio.h> |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 35 | #include <stdlib.h> |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 36 | #include <string.h> |
Robert Swiecki | 3bfc33c | 2016-03-14 18:12:41 +0100 | [diff] [blame] | 37 | #include <sys/queue.h> |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 38 | #include <unistd.h> |
| 39 | |
Robert Swiecki | 241a741 | 2017-05-24 01:53:15 +0200 | [diff] [blame] | 40 | #include "libcommon/common.h" |
Robert Swiecki | 241a741 | 2017-05-24 01:53:15 +0200 | [diff] [blame] | 41 | #include "libcommon/files.h" |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 42 | #include "libcommon/log.h" |
Robert Swiecki | 241a741 | 2017-05-24 01:53:15 +0200 | [diff] [blame] | 43 | #include "libcommon/util.h" |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 44 | |
| 45 | struct custom_option { |
| 46 | struct option opt; |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 47 | const char* descr; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 48 | }; |
| 49 | |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 50 | static bool checkFor_FILE_PLACEHOLDER(char** args) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 51 | { |
| 52 | for (int x = 0; args[x]; x++) { |
| 53 | if (strstr(args[x], _HF_FILE_PLACEHOLDER)) |
| 54 | return true; |
| 55 | } |
| 56 | return false; |
| 57 | } |
| 58 | |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 59 | static const char* cmdlineYesNo(bool yes) { return (yes ? "true" : "false"); } |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 60 | |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 61 | static void cmdlineHelp(const char* pname, struct custom_option* opts) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 62 | { |
| 63 | LOG_HELP_BOLD("Usage: %s [options] -- path_to_command [args]", pname); |
| 64 | LOG_HELP_BOLD("Options:"); |
| 65 | for (int i = 0; opts[i].opt.name; i++) { |
Robert Swiecki | f3a5f6a | 2016-03-16 14:47:30 +0100 | [diff] [blame] | 66 | if (isprint(opts[i].opt.val) && opts[i].opt.val < 0x80) { |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 67 | LOG_HELP_BOLD(" --%s%s%c %s", opts[i].opt.name, "|-", opts[i].opt.val, |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 68 | opts[i].opt.has_arg == required_argument ? "VALUE" : ""); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 69 | } else { |
| 70 | LOG_HELP_BOLD(" --%s %s", opts[i].opt.name, |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 71 | opts[i].opt.has_arg == required_argument ? "VALUE" : ""); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 72 | } |
| 73 | LOG_HELP("\t%s", opts[i].descr); |
| 74 | } |
Jagger | 3212737 | 2015-10-09 23:07:38 +0200 | [diff] [blame] | 75 | LOG_HELP_BOLD("\nExamples:"); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 76 | LOG_HELP(" Run the binary over a mutated file chosen from the directory. Disable fuzzing " |
| 77 | "feedback (dry/static mode)"); |
| 78 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -x -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
Jagger | 3212737 | 2015-10-09 23:07:38 +0200 | [diff] [blame] | 79 | LOG_HELP(" As above, provide input over STDIN:"); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 80 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -x -s -- /usr/bin/djpeg"); |
Jagger | e848cc7 | 2016-09-19 02:28:52 +0200 | [diff] [blame] | 81 | LOG_HELP(" Use compile-time instrumentation (libhfuzz/instrument.c):"); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 82 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
| 83 | LOG_HELP(" Use SANCOV instrumentation:"); |
| 84 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -C -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
| 85 | LOG_HELP(" Use persistent mode (libhfuzz/persistent.c) w/o instrumentation:"); |
| 86 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -P -x -- /usr/bin/tiffinfo_persistent"); |
| 87 | LOG_HELP(" Use persistent mode (libhfuzz/persistent.c) and compile-time instrumentation:"); |
Jagger | e848cc7 | 2016-09-19 02:28:52 +0200 | [diff] [blame] | 88 | LOG_HELP_BOLD(" " PROG_NAME " -f input_dir -P -- /usr/bin/tiffinfo_persistent"); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 89 | #if defined(_HF_ARCH_LINUX) |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 90 | LOG_HELP( |
| 91 | " Run the binary with dynamically generate inputs, maximize total no. of instructions:"); |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 92 | LOG_HELP_BOLD( |
| 93 | " " PROG_NAME " --linux_perf_instr -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 94 | LOG_HELP(" As above, maximize total no. of branches:"); |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 95 | LOG_HELP_BOLD( |
| 96 | " " PROG_NAME " --linux_perf_branch -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 97 | LOG_HELP(" As above, maximize unique branches (edges) via Intel BTS:"); |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 98 | LOG_HELP_BOLD( |
| 99 | " " PROG_NAME " --linux_perf_bts_edge -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 100 | LOG_HELP( |
| 101 | " As above, maximize unique code blocks via Intel Processor Trace (requires libipt.so):"); |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 102 | LOG_HELP_BOLD( |
| 103 | " " PROG_NAME " --linux_perf_ipt_block -- /usr/bin/tiffinfo -D " _HF_FILE_PLACEHOLDER); |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 104 | #endif /* defined(_HF_ARCH_LINUX) */ |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 105 | } |
| 106 | |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 107 | static void cmdlineUsage(const char* pname, struct custom_option* opts) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 108 | { |
| 109 | cmdlineHelp(pname, opts); |
| 110 | exit(0); |
| 111 | } |
| 112 | |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 113 | rlim_t cmdlineParseRLimit(int res, const char* optarg, unsigned long mul) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 114 | { |
| 115 | struct rlimit cur; |
| 116 | if (getrlimit(res, &cur) == -1) { |
| 117 | PLOG_F("getrlimit(%d)", res); |
| 118 | } |
| 119 | if (strcasecmp(optarg, "max") == 0) { |
| 120 | return cur.rlim_max; |
| 121 | } |
| 122 | if (strcasecmp(optarg, "def") == 0) { |
| 123 | return cur.rlim_cur; |
| 124 | } |
Anestis Bechtsoudis | 413cb13 | 2016-02-07 12:59:00 +0200 | [diff] [blame] | 125 | if (util_isANumber(optarg) == false) { |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 126 | LOG_F("RLIMIT %d needs a numeric or 'max'/'def' value ('%s' provided)", res, optarg); |
| 127 | } |
| 128 | rlim_t val = strtoul(optarg, NULL, 0) * mul; |
Jagger | 2bd61b7 | 2015-10-10 05:23:32 +0200 | [diff] [blame] | 129 | if ((unsigned long)val == ULONG_MAX && errno != 0) { |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 130 | PLOG_F("strtoul('%s', 0)", optarg); |
| 131 | } |
| 132 | return val; |
| 133 | } |
| 134 | |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 135 | bool cmdlineParse(int argc, char* argv[], honggfuzz_t* hfuzz) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 136 | { |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 137 | (*hfuzz) = (honggfuzz_t) |
| 138 | { |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 139 | .cmdline = NULL, |
Robert Swiecki | 72d2bef | 2016-01-19 14:39:26 +0100 | [diff] [blame] | 140 | .cmdline_txt[0] = '\0', |
Jagger | 1b2d482 | 2016-09-25 16:19:45 +0200 | [diff] [blame] | 141 | .inputDir = NULL, |
Robert Swiecki | 92a3136 | 2017-02-24 16:21:40 +0100 | [diff] [blame] | 142 | .inputDirP = NULL, |
| 143 | .fileCnt = 0, |
| 144 | .fileCntDone = false, |
Robert Swiecki | 4332ae9 | 2017-05-23 23:06:04 +0200 | [diff] [blame] | 145 | .nullifyStdio = true, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 146 | .fuzzStdin = false, |
| 147 | .saveUnique = true, |
Robert Swiecki | 6c9f682 | 2016-03-14 16:12:27 +0100 | [diff] [blame] | 148 | .useScreen = true, |
| 149 | .useVerifier = false, |
| 150 | .timeStart = time(NULL), |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 151 | .fileExtn = "fuzz", |
| 152 | .workDir = ".", |
Jagger | 1b2d482 | 2016-09-25 16:19:45 +0200 | [diff] [blame] | 153 | .covDir = NULL, |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 154 | .mutationsPerRun = 6U, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 155 | .externalCommand = NULL, |
Robert Swiecki | ee266ac | 2016-10-03 02:25:59 +0200 | [diff] [blame] | 156 | .postExternalCommand = NULL, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 157 | .blacklistFile = NULL, |
| 158 | .blacklistCnt = 0, |
| 159 | .blacklist = NULL, |
Jagger | f4a6056 | 2016-09-25 15:40:23 +0200 | [diff] [blame] | 160 | .maxFileSz = 0UL, |
Jagger | ba92b4b | 2016-03-16 02:24:17 +0100 | [diff] [blame] | 161 | .tmOut = 10, |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 162 | .runEndTime = 0, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 163 | .mutationsMax = 0, |
| 164 | .threadsFinished = 0, |
Jagger | 2664f54 | 2016-09-28 14:37:00 +0200 | [diff] [blame] | 165 | .threadsMax = (sysconf(_SC_NPROCESSORS_ONLN) <= 1) ? 1 : sysconf(_SC_NPROCESSORS_ONLN) / 2, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 166 | .reportFile = NULL, |
| 167 | .asLimit = 0ULL, |
Jagger | 80041fe | 2016-03-10 21:32:35 +0100 | [diff] [blame] | 168 | .clearEnv = false, |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 169 | .envs[0] = NULL, |
Robert Swiecki | 0f937af | 2016-03-30 18:19:16 +0200 | [diff] [blame] | 170 | .persistent = false, |
Robert Swiecki | e84b645 | 2016-12-12 12:42:04 +0100 | [diff] [blame] | 171 | .tmout_vtalrm = false, |
Robert Swiecki | 44f6b19 | 2017-02-15 20:24:55 +0100 | [diff] [blame] | 172 | .skipFeedbackOnTimeout = false, |
Anestis Bechtsoudis | e5f09f8 | 2016-12-27 16:06:05 +0200 | [diff] [blame] | 173 | .enableSanitizers = false, |
| 174 | #if defined(__ANDROID__) |
| 175 | .monitorSIGABRT = false, |
| 176 | #else |
| 177 | .monitorSIGABRT = true, |
| 178 | #endif |
Robert Swiecki | 0ec9811 | 2017-02-03 02:08:14 +0100 | [diff] [blame] | 179 | .threadsActiveCnt = 0, |
Robert Swiecki | 89b8447 | 2017-02-12 22:20:10 +0100 | [diff] [blame] | 180 | .mainPid = getpid(), |
Robert Swiecki | 8d01b01 | 2017-02-19 15:48:11 +0100 | [diff] [blame] | 181 | .terminating = false, |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 182 | .exitUponCrash = false, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 183 | |
Robert Swiecki | 531438a | 2016-09-13 19:05:11 +0200 | [diff] [blame] | 184 | .dictionaryFile = NULL, |
| 185 | .dictionaryCnt = 0, |
Robert Swiecki | 9f5f943 | 2017-03-09 01:48:04 +0100 | [diff] [blame] | 186 | .dictqCurrent = NULL, |
Robert Swiecki | 531438a | 2016-09-13 19:05:11 +0200 | [diff] [blame] | 187 | |
Robert Swiecki | 6c9f682 | 2016-03-14 16:12:27 +0100 | [diff] [blame] | 188 | .state = _HF_STATE_UNSET, |
Jagger | b7fa3ee | 2016-08-21 19:46:26 +0200 | [diff] [blame] | 189 | .feedback = NULL, |
Robert Swiecki | bc7532e | 2016-08-20 00:34:17 +0200 | [diff] [blame] | 190 | .bbFd = -1, |
Robert Swiecki | 9f5f943 | 2017-03-09 01:48:04 +0100 | [diff] [blame] | 191 | |
Robert Swiecki | e586c1f | 2016-03-14 18:46:03 +0100 | [diff] [blame] | 192 | .dynfileq_mutex = PTHREAD_MUTEX_INITIALIZER, |
Robert Swiecki | 3bfc33c | 2016-03-14 18:12:41 +0100 | [diff] [blame] | 193 | .dynfileqCnt = 0U, |
Robert Swiecki | 9f5f943 | 2017-03-09 01:48:04 +0100 | [diff] [blame] | 194 | .dynfileqCurrent = NULL, |
Robert Swiecki | 6c9f682 | 2016-03-14 16:12:27 +0100 | [diff] [blame] | 195 | |
Robert Swiecki | 37498fd | 2017-03-12 21:12:54 +0100 | [diff] [blame] | 196 | .feedback_mutex = PTHREAD_MUTEX_INITIALIZER, |
| 197 | |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 198 | .mutationsCnt = 0, |
| 199 | .crashesCnt = 0, |
| 200 | .uniqueCrashesCnt = 0, |
Anestis Bechtsoudis | 79b799e | 2015-11-01 00:02:25 +0200 | [diff] [blame] | 201 | .verifiedCrashesCnt = 0, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 202 | .blCrashesCnt = 0, |
| 203 | .timeoutedCnt = 0, |
| 204 | |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 205 | .dynFileMethod = _HF_DYNFILE_SOFT, |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 206 | .sanCovCnts = { |
Jagger | ab26e70 | 2016-03-22 04:28:00 +0100 | [diff] [blame] | 207 | .hitBBCnt = 0ULL, |
| 208 | .totalBBCnt = 0ULL, |
| 209 | .dsoCnt = 0ULL, |
| 210 | .iDsoCnt = 0ULL, |
| 211 | .newBBCnt = 0ULL, |
| 212 | .crashesCnt = 0ULL, |
| 213 | }, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 214 | |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 215 | .sanCov_mutex = PTHREAD_MUTEX_INITIALIZER, .sanOpts = { |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 216 | .asanOpts = NULL, |
| 217 | .msanOpts = NULL, |
| 218 | .ubsanOpts = NULL, |
Anestis Bechtsoudis | 61b5ab1 | 2016-01-08 16:07:02 +0200 | [diff] [blame] | 219 | }, |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 220 | .useSanCov = false, .covMetadata = NULL, |
Robert Swiecki | 6c9f682 | 2016-03-14 16:12:27 +0100 | [diff] [blame] | 221 | |
Haris Andrianakis | c9a7133 | 2016-05-09 21:56:30 -0700 | [diff] [blame] | 222 | .report_mutex = PTHREAD_MUTEX_INITIALIZER, |
| 223 | |
Robert Swiecki | 6c9f682 | 2016-03-14 16:12:27 +0100 | [diff] [blame] | 224 | /* Linux code */ |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 225 | .linux = { |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 226 | .exeFd = -1, |
| 227 | .hwCnts = { |
| 228 | .cpuInstrCnt = 0ULL, |
| 229 | .cpuBranchCnt = 0ULL, |
| 230 | .bbCnt = 0ULL, |
| 231 | .newBBCnt = 0ULL, |
| 232 | .softCntPc = 0ULL, |
| 233 | .softCntCmp = 0ULL, |
| 234 | }, |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 235 | .dynamicCutOffAddr = ~(0ULL), |
| 236 | .disableRandomization = true, |
| 237 | .ignoreAddr = NULL, |
| 238 | .numMajorFrames = 7, |
| 239 | .pid = 0, |
| 240 | .pidFile = NULL, |
| 241 | .pidCmd = NULL, |
| 242 | .symsBlFile = NULL, |
| 243 | .symsBlCnt = 0, |
| 244 | .symsBl = NULL, |
| 245 | .symsWlFile = NULL, |
| 246 | .symsWlCnt = 0, |
| 247 | .symsWl = NULL, |
| 248 | .cloneFlags = 0, |
| 249 | .kernelOnly = false, |
| 250 | .useClone = true, |
Jagger | ab26e70 | 2016-03-22 04:28:00 +0100 | [diff] [blame] | 251 | }, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 252 | }; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 253 | |
Robert Swiecki | afb1610 | 2017-03-13 22:14:31 +0100 | [diff] [blame] | 254 | TAILQ_INIT(&hfuzz->dynfileq); |
| 255 | TAILQ_INIT(&hfuzz->dictq); |
Robert Swiecki | 3bfc33c | 2016-03-14 18:12:41 +0100 | [diff] [blame] | 256 | |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 257 | // clang-format off |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 258 | struct custom_option custom_opts[] = { |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 259 | { { "help", no_argument, NULL, 'h' }, "Help plz.." }, |
| 260 | { { "input", required_argument, NULL, 'f' }, "Path to a directory containing initial file corpus" }, |
| 261 | { { "persistent", no_argument, NULL, 'P' }, "Enable persistent fuzzing (use hfuzz_cc/hfuzz-clang to compile code)" }, |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 262 | { { "instrument", no_argument, NULL, 'z' }, "*DEFAULT-MODE-BY-DEFAULT* Enable compile-time instrumentation (use hfuzz_cc/hfuzz-clang to compile code)" }, |
| 263 | { { "noinst", no_argument, NULL, 'x' }, "Static mode (dry-mode), disable any instrumentation (hw/sw)" }, |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 264 | { { "sancov", no_argument, NULL, 'C' }, "Enable sanitizer coverage feedback" }, |
| 265 | { { "keep_output", no_argument, NULL, 'Q' }, "Don't close children's stdin, stdout, stderr; can be noisy" }, |
| 266 | { { "timeout", required_argument, NULL, 't' }, "Timeout in seconds (default: '10')" }, |
| 267 | { { "threads", required_argument, NULL, 'n' }, "Number of concurrent fuzzing threads (default: number of CPUs / 2)" }, |
| 268 | { { "stdin_input", no_argument, NULL, 's' }, "Provide fuzzing input on STDIN, instead of ___FILE___" }, |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 269 | { { "mutations_per_run", required_argument, NULL, 'r' }, "Maximal number of mutations per one run, (default: '6')" }, |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 270 | { { "logfile", required_argument, NULL, 'l' }, "Log file" }, |
| 271 | { { "verbose", no_argument, NULL, 'v' }, "Disable ANSI console; use simple log output" }, |
| 272 | { { "verifier", no_argument, NULL, 'V' }, "Enable crashes verifier" }, |
| 273 | { { "debug_level", required_argument, NULL, 'd' }, "Debug level (0 - FATAL ... 4 - DEBUG), (default: '3' [INFO])" }, |
| 274 | { { "extension", required_argument, NULL, 'e' }, "Input file extension (e.g. 'swf'), (default: 'fuzz')" }, |
| 275 | { { "workspace", required_argument, NULL, 'W' }, "Workspace directory to save crashes & runtime files (default: '.')" }, |
| 276 | { { "covdir", required_argument, NULL, 0x103 }, "New coverage is written to a separate directory (default: use the input directory)" }, |
| 277 | { { "dict", required_argument, NULL, 'w' }, "Dictionary file. Format:http://llvm.org/docs/LibFuzzer.html#dictionaries" }, |
| 278 | { { "stackhash_bl", required_argument, NULL, 'B' }, "Stackhashes blacklist file (one entry per line)" }, |
| 279 | { { "mutate_cmd", required_argument, NULL, 'c' }, "External command producing fuzz files (instead of internal mutators)" }, |
| 280 | { { "pprocess_cmd", required_argument, NULL, 0x104 }, "External command postprocessing files produced by internal mutators" }, |
| 281 | { { "run_time", required_argument, NULL, 0x109 }, "Number of seconds this fuzzing session will last (default: '0' [no limit])" }, |
| 282 | { { "iterations", required_argument, NULL, 'N' }, "Number of fuzzing iterations (default: '0' [no limit])" }, |
| 283 | { { "rlimit_as", required_argument, NULL, 0x100 }, "Per process memory limit in MiB (default: '0' [no limit])" }, |
| 284 | { { "report", required_argument, NULL, 'R' }, "Write report to this file (default: '" _HF_REPORT_FILE "')" }, |
| 285 | { { "max_file_size", required_argument, NULL, 'F' }, "Maximal size of files processed by the fuzzer in bytes (default: '1048576')" }, |
| 286 | { { "clear_env", no_argument, NULL, 0x101 }, "Clear all environment variables before executing the binary" }, |
| 287 | { { "env", required_argument, NULL, 'E' }, "Pass this environment variable, can be used multiple times" }, |
| 288 | { { "save_all", no_argument, NULL, 'u' }, "Save all test-cases (not only the unique ones) by appending the current time-stamp to the filenames" }, |
| 289 | { { "tmout_sigvtalrm", no_argument, NULL, 'T' }, "Use SIGVTALRM to kill timeouting processes (default: use SIGKILL)" }, |
| 290 | { { "sanitizers", no_argument, NULL, 'S' }, "Enable sanitizers settings (default: false)" }, |
| 291 | { { "monitor_sigabrt", required_argument, NULL, 0x105 }, "Monitor SIGABRT (default: 'false for Android - 'true for other platforms)" }, |
| 292 | { { "no_fb_timeout", required_argument, NULL, 0x106 }, "Skip feedback if the process has timeouted (default: 'false')" }, |
| 293 | { { "exit_upon_crash", no_argument, NULL, 0x107 }, "Exit upon seeing the first crash (default: 'false')" }, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 294 | |
| 295 | #if defined(_HF_ARCH_LINUX) |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 296 | { { "linux_symbols_bl", required_argument, NULL, 0x504 }, "Symbols blacklist filter file (one entry per line)" }, |
| 297 | { { "linux_symbols_wl", required_argument, NULL, 0x505 }, "Symbols whitelist filter file (one entry per line)" }, |
| 298 | { { "linux_pid", required_argument, NULL, 'p' }, "Attach to a pid (and its thread group)" }, |
| 299 | { { "linux_file_pid", required_argument, NULL, 0x502 }, "Attach to pid (and its thread group) read from file" }, |
| 300 | { { "linux_addr_low_limit", required_argument, NULL, 0x500 }, "Address limit (from si.si_addr) below which crashes are not reported, (default: '0')" }, |
| 301 | { { "linux_keep_aslr", no_argument, NULL, 0x501 }, "Don't disable ASLR randomization, might be useful with MSAN" }, |
| 302 | { { "linux_perf_ignore_above", required_argument, NULL, 0x503 }, "Ignore perf events which report IPs above this address" }, |
| 303 | { { "linux_perf_instr", no_argument, NULL, 0x510 }, "Use PERF_COUNT_HW_INSTRUCTIONS perf" }, |
| 304 | { { "linux_perf_branch", no_argument, NULL, 0x511 }, "Use PERF_COUNT_HW_BRANCH_INSTRUCTIONS perf" }, |
| 305 | { { "linux_perf_bts_edge", no_argument, NULL, 0x513 }, "Use Intel BTS to count unique edges" }, |
| 306 | { { "linux_perf_ipt_block", no_argument, NULL, 0x514 }, "Use Intel Processor Trace to count unique blocks (requires libipt.so)" }, |
| 307 | { { "linux_perf_kernel_only", no_argument, NULL, 0x515 }, "Gather kernel-only coverage with Intel PT and with Intel BTS" }, |
| 308 | { { "linux_ns_net", no_argument, NULL, 0x0530 }, "Use Linux NET namespace isolation" }, |
| 309 | { { "linux_ns_pid", no_argument, NULL, 0x0531 }, "Use Linux PID namespace isolation" }, |
| 310 | { { "linux_ns_ipc", no_argument, NULL, 0x0532 }, "Use Linux IPC namespace isolation" }, |
| 311 | #endif // defined(_HF_ARCH_LINUX) |
| 312 | { { 0, 0, 0, 0 }, NULL }, |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 313 | }; |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 314 | // clang-format on |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 315 | |
| 316 | struct option opts[ARRAYSIZE(custom_opts)]; |
| 317 | for (unsigned i = 0; i < ARRAYSIZE(custom_opts); i++) { |
| 318 | opts[i] = custom_opts[i].opt; |
| 319 | } |
| 320 | |
| 321 | enum llevel_t ll = INFO; |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 322 | const char* logfile = NULL; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 323 | int opt_index = 0; |
| 324 | for (;;) { |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 325 | int c = getopt_long( |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 326 | argc, argv, "-?hQvVsuPxf:d:e:W:r:c:F:t:R:n:N:l:p:g:E:w:B:CzTS", opts, &opt_index); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 327 | if (c < 0) |
| 328 | break; |
| 329 | |
| 330 | switch (c) { |
| 331 | case 'h': |
| 332 | case '?': |
| 333 | cmdlineUsage(argv[0], custom_opts); |
| 334 | break; |
| 335 | case 'f': |
Jagger | 1b2d482 | 2016-09-25 16:19:45 +0200 | [diff] [blame] | 336 | hfuzz->inputDir = optarg; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 337 | break; |
Robert Swiecki | 930e12f | 2017-10-24 14:52:03 +0200 | [diff] [blame] | 338 | case 'x': |
| 339 | hfuzz->dynFileMethod = _HF_DYNFILE_NONE; |
| 340 | break; |
Robert Swiecki | 4332ae9 | 2017-05-23 23:06:04 +0200 | [diff] [blame] | 341 | case 'Q': |
| 342 | hfuzz->nullifyStdio = false; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 343 | break; |
| 344 | case 'v': |
| 345 | hfuzz->useScreen = false; |
| 346 | break; |
Anestis Bechtsoudis | 0cde66f | 2015-10-11 19:37:11 -0700 | [diff] [blame] | 347 | case 'V': |
| 348 | hfuzz->useVerifier = true; |
| 349 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 350 | case 's': |
| 351 | hfuzz->fuzzStdin = true; |
| 352 | break; |
| 353 | case 'u': |
| 354 | hfuzz->saveUnique = false; |
| 355 | break; |
Robert Swiecki | 03ef531 | 2015-10-09 18:25:40 +0200 | [diff] [blame] | 356 | case 'l': |
| 357 | logfile = optarg; |
| 358 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 359 | case 'd': |
| 360 | ll = atoi(optarg); |
| 361 | break; |
| 362 | case 'e': |
| 363 | hfuzz->fileExtn = optarg; |
| 364 | break; |
| 365 | case 'W': |
| 366 | hfuzz->workDir = optarg; |
| 367 | break; |
| 368 | case 'r': |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 369 | hfuzz->mutationsPerRun = strtoul(optarg, NULL, 10); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 370 | break; |
| 371 | case 'c': |
| 372 | hfuzz->externalCommand = optarg; |
| 373 | break; |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 374 | case 'C': |
| 375 | hfuzz->useSanCov = true; |
| 376 | break; |
Anestis Bechtsoudis | e5f09f8 | 2016-12-27 16:06:05 +0200 | [diff] [blame] | 377 | case 'S': |
| 378 | hfuzz->enableSanitizers = true; |
| 379 | break; |
Jagger | 4aac9fe | 2016-08-28 17:35:48 +0200 | [diff] [blame] | 380 | case 'z': |
| 381 | hfuzz->dynFileMethod |= _HF_DYNFILE_SOFT; |
| 382 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 383 | case 'F': |
| 384 | hfuzz->maxFileSz = strtoul(optarg, NULL, 0); |
| 385 | break; |
| 386 | case 't': |
| 387 | hfuzz->tmOut = atol(optarg); |
| 388 | break; |
| 389 | case 'R': |
| 390 | hfuzz->reportFile = optarg; |
| 391 | break; |
| 392 | case 'n': |
| 393 | hfuzz->threadsMax = atol(optarg); |
| 394 | break; |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 395 | case 0x109: { |
| 396 | time_t p = atol(optarg); |
| 397 | if (p > 0) { |
| 398 | hfuzz->runEndTime = time(NULL) + p; |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 399 | } |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 400 | } break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 401 | case 'N': |
| 402 | hfuzz->mutationsMax = atol(optarg); |
| 403 | break; |
Robert Swiecki | 03ef531 | 2015-10-09 18:25:40 +0200 | [diff] [blame] | 404 | case 0x100: |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 405 | hfuzz->asLimit = strtoull(optarg, NULL, 0); |
| 406 | break; |
Jagger | 80041fe | 2016-03-10 21:32:35 +0100 | [diff] [blame] | 407 | case 0x101: |
| 408 | hfuzz->clearEnv = true; |
| 409 | break; |
Robert Swiecki | dac8cf1 | 2016-09-22 15:36:28 +0200 | [diff] [blame] | 410 | case 0x103: |
Jagger | 1b2d482 | 2016-09-25 16:19:45 +0200 | [diff] [blame] | 411 | hfuzz->covDir = optarg; |
Robert Swiecki | dac8cf1 | 2016-09-22 15:36:28 +0200 | [diff] [blame] | 412 | break; |
Robert Swiecki | ee266ac | 2016-10-03 02:25:59 +0200 | [diff] [blame] | 413 | case 0x104: |
| 414 | hfuzz->postExternalCommand = optarg; |
| 415 | break; |
Anestis Bechtsoudis | e5f09f8 | 2016-12-27 16:06:05 +0200 | [diff] [blame] | 416 | case 0x105: |
| 417 | if ((strcasecmp(optarg, "0") == 0) || (strcasecmp(optarg, "false") == 0)) { |
| 418 | hfuzz->monitorSIGABRT = false; |
| 419 | } else { |
| 420 | hfuzz->monitorSIGABRT = true; |
| 421 | } |
| 422 | break; |
Robert Swiecki | 44f6b19 | 2017-02-15 20:24:55 +0100 | [diff] [blame] | 423 | case 0x106: |
| 424 | hfuzz->skipFeedbackOnTimeout = true; |
| 425 | break; |
Robert Swiecki | 069b48f | 2017-05-31 01:00:08 +0200 | [diff] [blame] | 426 | case 0x107: |
| 427 | hfuzz->exitUponCrash = true; |
| 428 | break; |
Robert Swiecki | fab6916 | 2016-03-31 15:41:36 +0200 | [diff] [blame] | 429 | case 'P': |
Robert Swiecki | 0f937af | 2016-03-30 18:19:16 +0200 | [diff] [blame] | 430 | hfuzz->persistent = true; |
| 431 | break; |
Gergely Nagy | 5d47c73 | 2016-12-12 23:51:51 +0100 | [diff] [blame] | 432 | case 'T': |
Robert Swiecki | e84b645 | 2016-12-12 12:42:04 +0100 | [diff] [blame] | 433 | hfuzz->tmout_vtalrm = true; |
| 434 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 435 | case 'p': |
Anestis Bechtsoudis | 413cb13 | 2016-02-07 12:59:00 +0200 | [diff] [blame] | 436 | if (util_isANumber(optarg) == false) { |
Jagger | 9c4d162 | 2015-10-16 01:40:17 +0200 | [diff] [blame] | 437 | LOG_E("-p '%s' is not a number", optarg); |
| 438 | return false; |
| 439 | } |
Jagger | 247c3b4 | 2016-03-21 23:24:05 +0100 | [diff] [blame] | 440 | hfuzz->linux.pid = atoi(optarg); |
| 441 | if (hfuzz->linux.pid < 1) { |
| 442 | LOG_E("-p '%d' is invalid", hfuzz->linux.pid); |
Jagger | 9c4d162 | 2015-10-16 01:40:17 +0200 | [diff] [blame] | 443 | return false; |
| 444 | } |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 445 | break; |
Robert Swiecki | fab6916 | 2016-03-31 15:41:36 +0200 | [diff] [blame] | 446 | case 0x502: |
Jagger | 247c3b4 | 2016-03-21 23:24:05 +0100 | [diff] [blame] | 447 | hfuzz->linux.pidFile = optarg; |
Anestis Bechtsoudis | 413cb13 | 2016-02-07 12:59:00 +0200 | [diff] [blame] | 448 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 449 | case 'E': |
| 450 | for (size_t i = 0; i < ARRAYSIZE(hfuzz->envs); i++) { |
| 451 | if (hfuzz->envs[i] == NULL) { |
| 452 | hfuzz->envs[i] = optarg; |
| 453 | break; |
| 454 | } |
| 455 | } |
| 456 | break; |
| 457 | case 'w': |
| 458 | hfuzz->dictionaryFile = optarg; |
| 459 | break; |
| 460 | case 'B': |
| 461 | hfuzz->blacklistFile = optarg; |
| 462 | break; |
Robert Swiecki | 846ccd7 | 2017-01-12 17:52:23 +0100 | [diff] [blame] | 463 | #if defined(_HF_ARCH_LINUX) |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 464 | case 0x500: |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 465 | hfuzz->linux.ignoreAddr = (void*)strtoul(optarg, NULL, 0); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 466 | break; |
| 467 | case 0x501: |
Jagger | 247c3b4 | 2016-03-21 23:24:05 +0100 | [diff] [blame] | 468 | hfuzz->linux.disableRandomization = false; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 469 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 470 | case 0x503: |
Jagger | 247c3b4 | 2016-03-21 23:24:05 +0100 | [diff] [blame] | 471 | hfuzz->linux.dynamicCutOffAddr = strtoull(optarg, NULL, 0); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 472 | break; |
Anestis Bechtsoudis | ba68b38 | 2016-10-29 20:44:15 +0300 | [diff] [blame] | 473 | case 0x504: |
| 474 | hfuzz->linux.symsBlFile = optarg; |
| 475 | break; |
| 476 | case 0x505: |
| 477 | hfuzz->linux.symsWlFile = optarg; |
| 478 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 479 | case 0x510: |
| 480 | hfuzz->dynFileMethod |= _HF_DYNFILE_INSTR_COUNT; |
| 481 | break; |
| 482 | case 0x511: |
| 483 | hfuzz->dynFileMethod |= _HF_DYNFILE_BRANCH_COUNT; |
| 484 | break; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 485 | case 0x513: |
Jagger | 3abc560 | 2016-02-04 00:53:43 +0100 | [diff] [blame] | 486 | hfuzz->dynFileMethod |= _HF_DYNFILE_BTS_EDGE; |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 487 | break; |
| 488 | case 0x514: |
Jagger | 39bd2b0 | 2016-02-04 01:16:15 +0100 | [diff] [blame] | 489 | hfuzz->dynFileMethod |= _HF_DYNFILE_IPT_BLOCK; |
| 490 | break; |
Robert Swiecki | 37d27ca | 2017-03-30 14:43:54 +0200 | [diff] [blame] | 491 | case 0x515: |
| 492 | hfuzz->linux.kernelOnly = true; |
| 493 | break; |
Robert Swiecki | 846ccd7 | 2017-01-12 17:52:23 +0100 | [diff] [blame] | 494 | case 0x530: |
| 495 | hfuzz->linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWNET); |
| 496 | break; |
| 497 | case 0x531: |
| 498 | hfuzz->linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWPID); |
| 499 | break; |
| 500 | case 0x532: |
| 501 | hfuzz->linux.cloneFlags |= (CLONE_NEWUSER | CLONE_NEWIPC); |
| 502 | break; |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 503 | #endif /* defined(_HF_ARCH_LINUX) */ |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 504 | default: |
| 505 | cmdlineUsage(argv[0], custom_opts); |
| 506 | return false; |
| 507 | break; |
| 508 | } |
| 509 | } |
Jagger | 72f258b | 2015-10-09 23:09:01 +0200 | [diff] [blame] | 510 | |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 511 | if (logInitLogFile(logfile, ll) == false) { |
| 512 | return false; |
| 513 | } |
| 514 | |
| 515 | hfuzz->cmdline = &argv[optind]; |
| 516 | if (hfuzz->cmdline[0] == NULL) { |
| 517 | LOG_E("No fuzz command provided"); |
| 518 | cmdlineUsage(argv[0], custom_opts); |
| 519 | return false; |
| 520 | } |
| 521 | |
Robert Swiecki | 0f937af | 2016-03-30 18:19:16 +0200 | [diff] [blame] | 522 | if (!hfuzz->fuzzStdin && !hfuzz->persistent && !checkFor_FILE_PLACEHOLDER(hfuzz->cmdline)) { |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 523 | LOG_E("You must specify '" _HF_FILE_PLACEHOLDER |
Robert Swiecki | 0f937af | 2016-03-30 18:19:16 +0200 | [diff] [blame] | 524 | "' when the -s (stdin fuzzing) or --persistent options are not set"); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 525 | return false; |
| 526 | } |
| 527 | |
Robert Swiecki | 5b775b2 | 2017-04-28 16:19:15 +0200 | [diff] [blame] | 528 | if (hfuzz->fuzzStdin && hfuzz->persistent) { |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 529 | LOG_E( |
| 530 | "Stdin fuzzing (-s) and persistent fuzzing (-P) cannot be specified at the same time"); |
Robert Swiecki | d633fe0 | 2017-04-28 17:40:27 +0200 | [diff] [blame] | 531 | return false; |
Robert Swiecki | 5b775b2 | 2017-04-28 16:19:15 +0200 | [diff] [blame] | 532 | } |
| 533 | |
Robert Swiecki | 71b7372 | 2016-09-05 15:18:25 +0200 | [diff] [blame] | 534 | if (hfuzz->threadsMax >= _HF_THREAD_MAX) { |
| 535 | LOG_E("Too many fuzzing threads specified %zu (>= _HF_THREAD_MAX (%u))", hfuzz->threadsMax, |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 536 | _HF_THREAD_MAX); |
Robert Swiecki | 71b7372 | 2016-09-05 15:18:25 +0200 | [diff] [blame] | 537 | return false; |
| 538 | } |
| 539 | |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 540 | if (strchr(hfuzz->fileExtn, '/')) { |
| 541 | LOG_E("The file extension contains the '/' character: '%s'", hfuzz->fileExtn); |
| 542 | return false; |
| 543 | } |
Anestis Bechtsoudis | be0ac7b | 2015-12-26 15:38:47 +0200 | [diff] [blame] | 544 | |
Anestis Bechtsoudis | 8f4aa61 | 2015-12-27 12:06:19 +0200 | [diff] [blame] | 545 | if (hfuzz->workDir[0] != '.' || strlen(hfuzz->workDir) > 2) { |
Anestis Bechtsoudis | c8e7f6e | 2015-12-26 14:48:48 +0200 | [diff] [blame] | 546 | if (!files_exists(hfuzz->workDir)) { |
| 547 | LOG_E("Provided workspace directory '%s' doesn't exist", hfuzz->workDir); |
| 548 | return false; |
| 549 | } |
| 550 | } |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 551 | |
Jagger | 247c3b4 | 2016-03-21 23:24:05 +0100 | [diff] [blame] | 552 | if (hfuzz->linux.pid > 0 || hfuzz->linux.pidFile) { |
| 553 | LOG_I("PID=%d specified, lowering maximum number of concurrent threads to 1", |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 554 | hfuzz->linux.pid); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 555 | hfuzz->threadsMax = 1; |
| 556 | } |
| 557 | |
Robert Swiecki | 13d9502 | 2017-11-04 12:15:41 +0100 | [diff] [blame^] | 558 | if (hfuzz->mutationsPerRun == 0U && hfuzz->useVerifier) { |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 559 | LOG_I("Verifier enabled with mutationsPerRun == 0, activating the dry run mode"); |
Anestis Bechtsoudis | 46ea10e | 2015-11-07 18:16:25 +0200 | [diff] [blame] | 560 | } |
| 561 | |
Anestis Bechtsoudis | c1a0d9f | 2016-12-29 11:34:10 +0200 | [diff] [blame] | 562 | /* |
| 563 | * 'enableSanitizers' can be auto enabled when 'useSanCov', although it's probably |
| 564 | * better to let user know about the features that each flag control. |
| 565 | */ |
| 566 | if (hfuzz->useSanCov == true && hfuzz->enableSanitizers == false) { |
| 567 | LOG_E("Sanitizer coverage cannot be used without enabling sanitizers '-S/--sanitizers'"); |
| 568 | return false; |
| 569 | } |
| 570 | |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 571 | LOG_I("PID: %d, inputDir '%s', nullifyStdio: %s, fuzzStdin: %s, saveUnique: %s, " |
| 572 | "mutationsPerRun: %u, " |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 573 | "externalCommand: '%s', runEndTime: %d tmOut: %ld, mutationsMax: %zu, threadsMax: %zu, " |
| 574 | "fileExtn: '%s', " |
Anestis Bechtsoudis | ecab776 | 2016-12-27 18:27:30 +0200 | [diff] [blame] | 575 | "memoryLimit: 0x%" PRIx64 "(MiB), fuzzExe: '%s', fuzzedPid: %d, monitorSIGABRT: '%s'", |
Robert Swiecki | 0b56611 | 2017-10-17 17:39:07 +0200 | [diff] [blame] | 576 | (int)getpid(), hfuzz->inputDir, cmdlineYesNo(hfuzz->nullifyStdio), |
Robert Swiecki | 10e9356 | 2017-11-04 00:57:47 +0100 | [diff] [blame] | 577 | cmdlineYesNo(hfuzz->fuzzStdin), cmdlineYesNo(hfuzz->saveUnique), hfuzz->mutationsPerRun, |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 578 | hfuzz->externalCommand == NULL ? "NULL" : hfuzz->externalCommand, (int)hfuzz->runEndTime, |
| 579 | hfuzz->tmOut, hfuzz->mutationsMax, hfuzz->threadsMax, hfuzz->fileExtn, hfuzz->asLimit, |
| 580 | hfuzz->cmdline[0], hfuzz->linux.pid, cmdlineYesNo(hfuzz->monitorSIGABRT)); |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 581 | |
Robert Swiecki | 2aaa52b | 2016-01-19 14:40:47 +0100 | [diff] [blame] | 582 | snprintf(hfuzz->cmdline_txt, sizeof(hfuzz->cmdline_txt), "%s", hfuzz->cmdline[0]); |
Robert Swiecki | 72d2bef | 2016-01-19 14:39:26 +0100 | [diff] [blame] | 583 | for (size_t i = 1; hfuzz->cmdline[i]; i++) { |
| 584 | util_ssnprintf(hfuzz->cmdline_txt, sizeof(hfuzz->cmdline_txt), " %s", hfuzz->cmdline[i]); |
Robert Swiecki | f2d9c3a | 2016-11-03 02:13:54 +0100 | [diff] [blame] | 585 | if (strlen(hfuzz->cmdline_txt) == (sizeof(hfuzz->cmdline_txt) - 1)) { |
| 586 | hfuzz->cmdline_txt[sizeof(hfuzz->cmdline_txt) - 3] = '.'; |
| 587 | hfuzz->cmdline_txt[sizeof(hfuzz->cmdline_txt) - 2] = '.'; |
| 588 | hfuzz->cmdline_txt[sizeof(hfuzz->cmdline_txt) - 1] = '.'; |
| 589 | } |
Robert Swiecki | 72d2bef | 2016-01-19 14:39:26 +0100 | [diff] [blame] | 590 | } |
| 591 | |
Robert Swiecki | a88f96f | 2015-10-09 16:47:39 +0200 | [diff] [blame] | 592 | return true; |
| 593 | } |