def generate(grammar=None,
num=1,
output=sys.stdout,
max_recursion=10,
seed=None):
"""Load and generate ``num`` number of top-level rules from the specified grammar.
:param list grammar: The grammar file to load and generate data from
:param int num: The number of times to generate data
:param output: The output destination (an open, writable stream-type object. default=``sys.stdout``)
:param int max_recursion: The maximum reference-recursion when generating data (default=``10``)
:param int seed: The seed to initialize the PRNG with. If None, will not initialize it.
"""
if seed is not None:
gramfuzz.rand.seed(seed)
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar(grammar)
cat_group = os.path.basename(grammar).replace(".py", "")
results = fuzzer.gen(cat_group=cat_group,
num=num,
max_recursion=max_recursion)
for res in results:
output.write(res)
def test_gramfuzz(grammar, start_symbol, tries):
grammar = "grammars/" + grammar + ".py"
start = time.time()
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar(grammar)
result = fuzzer.gen(cat=start_symbol, num=tries, max_recursion=10)
end = time.time()
runtime = end - start
return runtime
def generate_json(path):
grammar = gramfuzz.GramFuzzer()
grammar.load_grammar(path)
for x in grammar.gen(cat="json", num=10, max_recursion=10):
if x not in ["{}", "[]"]:
j = json.loads(x)
del grammar
return j
return {"dummy": 1}
def generate(self):
print('\nGenerating seeds...')
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar(self._feed)
for i in range(self._file_num):
bc_inputs = fuzzer.gen(cat="bc_input", num=1)
with open('input/input{}'.format(i), 'w') as f:
for bc_input in bc_inputs:
f.write(bc_input.decode('utf-8') + '\n')
f.write('quit')
print('{} files generated. Start fuzzing...'.format(self._file_num))
def generate_input(file_path):
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar(file_path)
for i in range(file_number):
print('Generating: input{}'.format(i))
bc_inputs = fuzzer.gen(cat="bc_input", num=input_number)
with open('input{}'.format(i), 'w') as f:
for bc_input in bc_inputs:
f.write(bc_input.decode('utf-8') + '\n')
f.write('quit')
#print('Finished: input{}'.format(i))
print('Finished generated inputs')
def generate_syntatically_valid_yaml():
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar("yaml_grammar.py")
yaml_dat = fuzzer.gen(cat="yamlfile", num=1)[0]
# in theory, at this point, the YAML should survive 'netplan generate'.
# now we expect netplan generate to make the checks around e.g. the
# things NM can't render (e.g. bug 3, bug 4), so those sorts of things
# should really be sorted out and the grammar level.
if TEST_GENERATE:
with open('/etc/netplan/fuzz.yaml', 'w') as f:
f.write(yaml_dat)
if os.system("netplan generate") != 0:
exit(1)
return yaml_dat
def main():
num_files = 50
parser = argparse.ArgumentParser(description='YANG model grammar fuzzer')
parser.add_argument('--num_files', '-N', help="number of models to generate", type=int)
args = parser.parse_args()
path = "./corpus/"
if not os.path.isdir(path):
os.makedirs(path)
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar("container-grammar.py")
for i in progressbar.progressbar(range(num_files)):
configs = fuzzer.gen(cat="container", num=1)
f = open(f"./{path}/{str(i)}.yang", "wb")
f.write(configs[0])
f.close()
def main():
global num_files
parser = argparse.ArgumentParser(description='YANG model grammar fuzzer')
parser.add_argument('--num_files',
'-N',
help="number of models to generate",
type=int)
args = parser.parse_args()
if args.num_files:
num_files = args.num_files
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar("yang_grammar.py")
for i in progressbar.progressbar(range(num_files)):
configs = fuzzer.gen(cat="yang", num=1)
f = open("./configs/" + str(i) + ".yang", "w")
f.write(configs[0])
f.close()
def main():
parser = ArgumentParser()
parser.add_argument("-o",
"--out",
dest="out_dir",
default="output/",
help="the output directory for the fuzzed files")
parser.add_argument("-n",
dest="num",
default="10",
type=int,
help="number of files that should be produced")
parser.add_argument("--vim_format",
dest="vim_format",
action="store_true",
help="format the output files with vim")
args = parser.parse_args()
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"minijava_grammar.py"))
minijava = fuzzer.gen(cat="minijava", num=args.num, auto_process=False)
for i in range(0, args.num):
filename = args.out_dir + "/" + uuid.uuid4().hex + ".java"
with open(filename, "w") as file:
file.write(minijava[i])
if args.vim_format:
os.system("""vim +"execute 'normal! =G' | :wq! """ + filename +
"""" """ + filename)
new_c = chr(ord(c) ^ bit)
# print("Flipping", bit, "in", repr(c) + ", giving", repr(new_c))
return s[:pos] + new_c + s[pos + 1:]
def mutate(s):
"""Return s with a random mutation applied"""
mutators = [
delete_random_character, insert_random_character, flip_random_character
]
mutator = random.choice(mutators)
# print(mutator)
return mutator(s)
fuzzer = gramfuzz.GramFuzzer()
fuzzer.load_grammar('./bin/jsonmgrammar.py')
strings = {}
estrings = {}
import sys
def dump_and_flush(f, s):
sys.stdout.flush()
pickle.dump(s, f)
f.flush()
import pickle
def setUp(self):
self.fuzzer = gramfuzz.GramFuzzer()
def main():
parser = ArgumentParser()
parser.add_argument("-o",
"--out",
dest="out_dir",
default="output/",
help="the output directory for the fuzzed files")
parser.add_argument("-n",
dest="num",
default="10",
type=int,
help="number of files that should be produced")
parser.add_argument("--vim_format",
dest="vim_format",
action="store_true",
help="format the output files with vim")
parser.add_argument("--token",
dest="token",
action="store_true",
help="generate token list file")
parser.add_argument(
"--lexer",
dest="lexer",
action="store_true",
help="fuzz lexer test cases without caring about the syntax")
args = parser.parse_args()
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
fuzzer = gramfuzz.GramFuzzer()
fuzzer.set_max_recursion(RECURSION_LIMIT)
ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
grammar = "minijava_grammar.py"
category = "minijava"
if args.lexer:
grammar = "lexer_grammar.py"
category = "minijava_lex"
fuzzer.load_grammar(os.path.join(ROOT_DIR, grammar))
(tokens, minijava) = fuzzer.gen(
cat=category,
num=args.num,
auto_process=False,
)
for i in range(0, args.num):
filename = args.out_dir + "/" + uuid.uuid4().hex + ".mj"
with open(filename, "w") as file:
file.write(minijava[i])
if args.token:
with open(filename + ".out", "w") as file:
file.write(tokens[i] + "\nEOF")
if args.vim_format:
os.system("""vim +"execute 'normal! =G' | :wq! """ + filename +
""".java" """ + filename + ".java")
def setUp(self):
gramfuzz.GramFuzzer.__instance__ = None
self.fuzzer = gramfuzz.GramFuzzer()
