ffd1746d03
This commit merges the latest LLVM sources from the vendor space. It also updates the build glue to match the new sources. Clang's version number is changed to match LLVM's, which means /usr/include/clang/2.0 has been renamed to /usr/include/clang/2.8. Obtained from: projects/clangbsd
341 lines
12 KiB
Python
Executable File
341 lines
12 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
"""
|
|
This is a generic fuzz testing tool, see --help for more information.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import random
|
|
import subprocess
|
|
import itertools
|
|
|
|
class TestGenerator:
|
|
def __init__(self, inputs, delete, insert, replace,
|
|
insert_strings, pick_input):
|
|
self.inputs = [(s, open(s).read()) for s in inputs]
|
|
|
|
self.delete = bool(delete)
|
|
self.insert = bool(insert)
|
|
self.replace = bool(replace)
|
|
self.pick_input = bool(pick_input)
|
|
self.insert_strings = list(insert_strings)
|
|
|
|
self.num_positions = sum([len(d) for _,d in self.inputs])
|
|
self.num_insert_strings = len(insert_strings)
|
|
self.num_tests = ((delete + (insert + replace)*self.num_insert_strings)
|
|
* self.num_positions)
|
|
self.num_tests += 1
|
|
|
|
if self.pick_input:
|
|
self.num_tests *= self.num_positions
|
|
|
|
def position_to_source_index(self, position):
|
|
for i,(s,d) in enumerate(self.inputs):
|
|
n = len(d)
|
|
if position < n:
|
|
return (i,position)
|
|
position -= n
|
|
raise ValueError,'Invalid position.'
|
|
|
|
def get_test(self, index):
|
|
assert 0 <= index < self.num_tests
|
|
|
|
picked_position = None
|
|
if self.pick_input:
|
|
index,picked_position = divmod(index, self.num_positions)
|
|
picked_position = self.position_to_source_index(picked_position)
|
|
|
|
if index == 0:
|
|
return ('nothing', None, None, picked_position)
|
|
|
|
index -= 1
|
|
index,position = divmod(index, self.num_positions)
|
|
position = self.position_to_source_index(position)
|
|
if self.delete:
|
|
if index == 0:
|
|
return ('delete', position, None, picked_position)
|
|
index -= 1
|
|
|
|
index,insert_index = divmod(index, self.num_insert_strings)
|
|
insert_str = self.insert_strings[insert_index]
|
|
if self.insert:
|
|
if index == 0:
|
|
return ('insert', position, insert_str, picked_position)
|
|
index -= 1
|
|
|
|
assert self.replace
|
|
assert index == 0
|
|
return ('replace', position, insert_str, picked_position)
|
|
|
|
class TestApplication:
|
|
def __init__(self, tg, test):
|
|
self.tg = tg
|
|
self.test = test
|
|
|
|
def apply(self):
|
|
if self.test[0] == 'nothing':
|
|
pass
|
|
else:
|
|
i,j = self.test[1]
|
|
name,data = self.tg.inputs[i]
|
|
if self.test[0] == 'delete':
|
|
data = data[:j] + data[j+1:]
|
|
elif self.test[0] == 'insert':
|
|
data = data[:j] + self.test[2] + data[j:]
|
|
elif self.test[0] == 'replace':
|
|
data = data[:j] + self.test[2] + data[j+1:]
|
|
else:
|
|
raise ValueError,'Invalid test %r' % self.test
|
|
open(name,'wb').write(data)
|
|
|
|
def revert(self):
|
|
if self.test[0] != 'nothing':
|
|
i,j = self.test[1]
|
|
name,data = self.tg.inputs[i]
|
|
open(name,'wb').write(data)
|
|
|
|
def quote(str):
|
|
return '"' + str + '"'
|
|
|
|
def run_one_test(test_application, index, input_files, args):
|
|
test = test_application.test
|
|
|
|
# Interpolate arguments.
|
|
options = { 'index' : index,
|
|
'inputs' : ' '.join(quote(f) for f in input_files) }
|
|
|
|
# Add picked input interpolation arguments, if used.
|
|
if test[3] is not None:
|
|
pos = test[3][1]
|
|
options['picked_input'] = input_files[test[3][0]]
|
|
options['picked_input_pos'] = pos
|
|
# Compute the line and column.
|
|
file_data = test_application.tg.inputs[test[3][0]][1]
|
|
line = column = 1
|
|
for i in range(pos):
|
|
c = file_data[i]
|
|
if c == '\n':
|
|
line += 1
|
|
column = 1
|
|
else:
|
|
column += 1
|
|
options['picked_input_line'] = line
|
|
options['picked_input_col'] = column
|
|
|
|
test_args = [a % options for a in args]
|
|
if opts.verbose:
|
|
print '%s: note: executing %r' % (sys.argv[0], test_args)
|
|
|
|
stdout = None
|
|
stderr = None
|
|
if opts.log_dir:
|
|
stdout_log_path = os.path.join(opts.log_dir, '%s.out' % index)
|
|
stderr_log_path = os.path.join(opts.log_dir, '%s.err' % index)
|
|
stdout = open(stdout_log_path, 'wb')
|
|
stderr = open(stderr_log_path, 'wb')
|
|
else:
|
|
sys.stdout.flush()
|
|
p = subprocess.Popen(test_args, stdout=stdout, stderr=stderr)
|
|
p.communicate()
|
|
exit_code = p.wait()
|
|
|
|
test_result = (exit_code == opts.expected_exit_code or
|
|
exit_code in opts.extra_exit_codes)
|
|
|
|
if stdout is not None:
|
|
stdout.close()
|
|
stderr.close()
|
|
|
|
# Remove the logs for passes, unless logging all results.
|
|
if not opts.log_all and test_result:
|
|
os.remove(stdout_log_path)
|
|
os.remove(stderr_log_path)
|
|
|
|
if not test_result:
|
|
print 'FAIL: %d' % index
|
|
elif not opts.succinct:
|
|
print 'PASS: %d' % index
|
|
|
|
def main():
|
|
global opts
|
|
from optparse import OptionParser, OptionGroup
|
|
parser = OptionParser("""%prog [options] ... test command args ...
|
|
|
|
%prog is a tool for fuzzing inputs and testing them.
|
|
|
|
The most basic usage is something like:
|
|
|
|
$ %prog --file foo.txt ./test.sh
|
|
|
|
which will run a default list of fuzzing strategies on the input. For each
|
|
fuzzed input, it will overwrite the input files (in place), run the test script,
|
|
then restore the files back to their original contents.
|
|
|
|
NOTE: You should make sure you have a backup copy of your inputs, in case
|
|
something goes wrong!!!
|
|
|
|
You can cause the fuzzing to not restore the original files with
|
|
'--no-revert'. Generally this is used with '--test <index>' to run one failing
|
|
test and then leave the fuzzed inputs in place to examine the failure.
|
|
|
|
For each fuzzed input, %prog will run the test command given on the command
|
|
line. Each argument in the command is subject to string interpolation before
|
|
being executed. The syntax is "%(VARIABLE)FORMAT" where FORMAT is a standard
|
|
printf format, and VARIBLE is one of:
|
|
|
|
'index' - the test index being run
|
|
'inputs' - the full list of test inputs
|
|
'picked_input' - (with --pick-input) the selected input file
|
|
'picked_input_pos' - (with --pick-input) the selected input position
|
|
'picked_input_line' - (with --pick-input) the selected input line
|
|
'picked_input_col' - (with --pick-input) the selected input column
|
|
|
|
By default, the script will run forever continually picking new tests to
|
|
run. You can limit the number of tests that are run with '--max-tests <number>',
|
|
and you can run a particular test with '--test <index>'.
|
|
""")
|
|
parser.add_option("-v", "--verbose", help="Show more output",
|
|
action='store_true', dest="verbose", default=False)
|
|
parser.add_option("-s", "--succinct", help="Reduce amount of output",
|
|
action="store_true", dest="succinct", default=False)
|
|
|
|
group = OptionGroup(parser, "Test Execution")
|
|
group.add_option("", "--expected-exit-code", help="Set expected exit code",
|
|
type=int, dest="expected_exit_code",
|
|
default=0)
|
|
group.add_option("", "--extra-exit-code",
|
|
help="Set additional expected exit code",
|
|
type=int, action="append", dest="extra_exit_codes",
|
|
default=[])
|
|
group.add_option("", "--log-dir",
|
|
help="Capture test logs to an output directory",
|
|
type=str, dest="log_dir",
|
|
default=None)
|
|
group.add_option("", "--log-all",
|
|
help="Log all outputs (not just failures)",
|
|
action="store_true", dest="log_all", default=False)
|
|
parser.add_option_group(group)
|
|
|
|
group = OptionGroup(parser, "Input Files")
|
|
group.add_option("", "--file", metavar="PATH",
|
|
help="Add an input file to fuzz",
|
|
type=str, action="append", dest="input_files", default=[])
|
|
group.add_option("", "--filelist", metavar="LIST",
|
|
help="Add a list of inputs files to fuzz (one per line)",
|
|
type=int, action="append", dest="filelists", default=[])
|
|
parser.add_option_group(group)
|
|
|
|
group = OptionGroup(parser, "Fuzz Options")
|
|
group.add_option("", "--replacement-chars", dest="replacement_chars",
|
|
help="Characters to insert/replace",
|
|
default="0{}[]<>\;@#$^%& ")
|
|
group.add_option("", "--replacement-string", dest="replacement_strings",
|
|
action="append", help="Add a replacement string to use",
|
|
default=[])
|
|
group.add_option("", "--replacement-list", dest="replacement_lists",
|
|
help="Add a list of replacement strings (one per line)",
|
|
action="append", default=[])
|
|
group.add_option("", "--no-delete", help="Don't delete characters",
|
|
action='store_false', dest="enable_delete", default=True)
|
|
group.add_option("", "--no-insert", help="Don't insert strings",
|
|
action='store_false', dest="enable_insert", default=True)
|
|
group.add_option("", "--no-replace", help="Don't replace strings",
|
|
action='store_false', dest="enable_replace", default=True)
|
|
group.add_option("", "--no-revert", help="Don't revert changes",
|
|
action='store_false', dest="revert", default=True)
|
|
parser.add_option_group(group)
|
|
|
|
group = OptionGroup(parser, "Test Selection")
|
|
group.add_option("", "--test", help="Run a particular test",
|
|
type=int, dest="test", default=None, metavar="INDEX")
|
|
group.add_option("", "--max-tests", help="Maximum number of tests",
|
|
type=int, dest="max_tests", default=10, metavar="COUNT")
|
|
group.add_option("", "--pick-input",
|
|
help="Randomly select an input byte as well as fuzzing",
|
|
action='store_true', dest="pick_input", default=False)
|
|
parser.add_option_group(group)
|
|
|
|
parser.disable_interspersed_args()
|
|
|
|
(opts, args) = parser.parse_args()
|
|
|
|
if not args:
|
|
parser.error("Invalid number of arguments")
|
|
|
|
# Collect the list of inputs.
|
|
input_files = list(opts.input_files)
|
|
for filelist in opts.filelists:
|
|
f = open(filelist)
|
|
try:
|
|
for ln in f:
|
|
ln = ln.strip()
|
|
if ln:
|
|
input_files.append(ln)
|
|
finally:
|
|
f.close()
|
|
input_files.sort()
|
|
|
|
if not input_files:
|
|
parser.error("No input files!")
|
|
|
|
print '%s: note: fuzzing %d files.' % (sys.argv[0], len(input_files))
|
|
|
|
# Make sure the log directory exists if used.
|
|
if opts.log_dir:
|
|
if not os.path.exists(opts.log_dir):
|
|
try:
|
|
os.mkdir(opts.log_dir)
|
|
except OSError:
|
|
print "%s: error: log directory couldn't be created!" % (
|
|
sys.argv[0],)
|
|
raise SystemExit,1
|
|
|
|
# Get the list if insert/replacement strings.
|
|
replacements = list(opts.replacement_chars)
|
|
replacements.extend(opts.replacement_strings)
|
|
for replacement_list in opts.replacement_lists:
|
|
f = open(replacement_list)
|
|
try:
|
|
for ln in f:
|
|
ln = ln[:-1]
|
|
if ln:
|
|
replacements.append(ln)
|
|
finally:
|
|
f.close()
|
|
|
|
# Unique and order the replacement list.
|
|
replacements = list(set(replacements))
|
|
replacements.sort()
|
|
|
|
# Create the test generator.
|
|
tg = TestGenerator(input_files, opts.enable_delete, opts.enable_insert,
|
|
opts.enable_replace, replacements, opts.pick_input)
|
|
|
|
print '%s: note: %d input bytes.' % (sys.argv[0], tg.num_positions)
|
|
print '%s: note: %d total tests.' % (sys.argv[0], tg.num_tests)
|
|
if opts.test is not None:
|
|
it = [opts.test]
|
|
elif opts.max_tests is not None:
|
|
it = itertools.imap(random.randrange,
|
|
itertools.repeat(tg.num_tests, opts.max_tests))
|
|
else:
|
|
it = itertools.imap(random.randrange, itertools.repeat(tg.num_tests))
|
|
for test in it:
|
|
t = tg.get_test(test)
|
|
|
|
if opts.verbose:
|
|
print '%s: note: running test %d: %r' % (sys.argv[0], test, t)
|
|
ta = TestApplication(tg, t)
|
|
try:
|
|
ta.apply()
|
|
run_one_test(ta, test, input_files, args)
|
|
finally:
|
|
if opts.revert:
|
|
ta.revert()
|
|
|
|
sys.stdout.flush()
|
|
|
|
if __name__ == '__main__':
|
|
main()
|