def test_fuzz_rangelist(self):
inputlen = 10000
iterations = 100
r = [(0, 100), (600, 1000), (3000, 10000)]
_input, chars_inserted = _insert_crlf(bytearray('A' * inputlen))
for i in xrange(iterations):
fuzzed = fuzz(
fuzz_input=copy.copy(_input),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=r,
fuzzable_chars=[0x0D],
)
self.assertEqual(inputlen, len(fuzzed))
self.assertNotEqual(_input, fuzzed)
for (a, b) in r:
# make sure we didn't change the exclude ranges
self.assertEqual(_input[a:b + 1], fuzzed[a:b + 1])
hd = bytewise_hd(_input, fuzzed)
self.assertGreater(hd, 0)
self.assertLess(hd, chars_inserted)
# we excluded all but 2500 bytes in r above
actual_ratio = hd / 2500.0
self.assertGreaterEqual(actual_ratio, 0.01)
self.assertLessEqual(actual_ratio, 0.03)
def test_fuzz_rangelist(self):
inputlen = 10000
iterations = 100
r = [(0, 100), (600, 1000), (3000, 10000)]
_input, chars_inserted = _insert_crlf(bytearray('A' * inputlen))
for i in xrange(iterations):
fuzzed = fuzz(fuzz_input=copy.copy(_input),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=r,
fuzzable_chars=[0x0D],
)
self.assertEqual(inputlen, len(fuzzed))
self.assertNotEqual(_input, fuzzed)
for (a, b) in r:
# make sure we didn't change the exclude ranges
self.assertEqual(_input[a:b + 1], fuzzed[a:b + 1])
hd = bytewise_hd(_input, fuzzed)
self.assertGreater(hd, 0)
self.assertLess(hd, chars_inserted)
# we excluded all but 2500 bytes in r above
actual_ratio = hd / 2500.0
self.assertGreaterEqual(actual_ratio, 0.01)
self.assertLessEqual(actual_ratio, 0.03)
def _test_fuzz(self, inputlen=1000, iterations=100, rangelist=None):
_input = bytearray('A' * inputlen)
# sub in null chars
chars_inserted = 0
for i in xrange(0, inputlen, 10):
_input[i] = 0x0D
chars_inserted += 1
for i in xrange(iterations):
fuzzed = fuzz(fuzz_input=copy.copy(_input),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=rangelist,
fuzzable_chars=[0x0D]
)
self.assertEqual(inputlen, len(fuzzed))
self.assertNotEqual(_input, fuzzed)
hd = bytewise_hd(_input, fuzzed)
self.assertGreater(hd, 0)
self.assertLessEqual(hd, chars_inserted)
actual_ratio = hd / float(chars_inserted)
self.assertGreaterEqual(actual_ratio, 0.1)
self.assertLessEqual(actual_ratio, 0.3)
def test_fuzz_rangelist(self):
inputlen = 10000
iterations = 100
r = [(0, 100), (600, 1000), (3000, 10000)]
for i in xrange(iterations):
fuzzed = fuzz(
fuzz_input=_input(inputlen),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=r,
)
self.assertEqual(inputlen, len(fuzzed))
self._fail_if_not_fuzzed(fuzzed)
for (a, b) in r:
# make sure we didn't change the exclude ranges
self.assertEqual(_input(inputlen)[a:b + 1], fuzzed[a:b + 1])
hd = bytewise_hd(_input(inputlen), fuzzed)
self.assertGreater(hd, 0)
self.assertLess(hd, inputlen)
# we excluded all but 2500 bytes in r above
actual_ratio = hd / 2500.0
self.assertGreaterEqual(actual_ratio, 0.1)
self.assertLessEqual(actual_ratio, 0.3)
def _test_fuzz(self, inputlen=1000, iterations=100, rangelist=None):
_input = bytearray('A' * inputlen)
# sub in null chars
chars_inserted = 0
for i in xrange(0, inputlen, 10):
_input[i] = 0x0D
chars_inserted += 1
for i in xrange(iterations):
fuzzed = fuzz(fuzz_input=copy.copy(_input),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=rangelist,
fuzzable_chars=[0x0D])
self.assertEqual(inputlen, len(fuzzed))
self.assertNotEqual(_input, fuzzed)
hd = bytewise_hd(_input, fuzzed)
self.assertGreater(hd, 0)
self.assertLessEqual(hd, chars_inserted)
actual_ratio = hd / float(chars_inserted)
self.assertGreaterEqual(actual_ratio, 0.1)
self.assertLessEqual(actual_ratio, 0.3)
def test_fuzz_rangelist(self):
inputlen = 10000
iterations = 100
r = [(0, 100), (600, 1000), (3000, 10000)]
for i in xrange(iterations):
fuzzed = fuzz(fuzz_input=_input(inputlen),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=r,
)
self.assertEqual(inputlen, len(fuzzed))
self._fail_if_not_fuzzed(fuzzed)
for (a, b) in r:
# make sure we didn't change the exclude ranges
self.assertEqual(_input(inputlen)[a:b + 1], fuzzed[a:b + 1])
hd = bytewise_hd(_input(inputlen), fuzzed)
self.assertGreater(hd, 0)
self.assertLess(hd, inputlen)
# we excluded all but 2500 bytes in r above
actual_ratio = hd / 2500.0
self.assertGreaterEqual(actual_ratio, 0.1)
self.assertLessEqual(actual_ratio, 0.3)
def calculate_hamming_distances_a(self):
with open(self.fuzzedfile.path, 'rb') as fd:
fuzzed = fd.read()
a_string = 'x' * len(fuzzed)
self.hd_bits = hamming.bitwise_hd(a_string, fuzzed)
self.hd_bytes = hamming.bytewise_hd(a_string, fuzzed)
def calculate_hamming_distances_a(self):
with open(self.fuzzedfile.path, 'rb') as fd:
fuzzed = fd.read()
a_string = 'x' * len(fuzzed)
self.hd_bits = hamming.bitwise_hd(a_string, fuzzed)
self.hd_bytes = hamming.bytewise_hd(a_string, fuzzed)
def test_set_discard_chance(self):
self.m.seed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
self.m.fuzzed = "abcdefghijklmnopqrstuvwxyz"
self.m.min_distance = hamming.bytewise_hd(self.m.seed, self.m.fuzzed)
self.assertEqual(self.m.min_distance, 26)
for tsg in xrange(1, 20):
self.m.target_size_guess = tsg
self.m.set_discard_chance()
self.assertAlmostEqual(self.m.discard_chance, 1.0 / (1.0 + tsg))
def test_set_discard_chance(self):
self.m.seed = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
self.m.fuzzed = "abcdefghijklmnopqrstuvwxyz"
self.m.min_distance = hamming.bytewise_hd(self.m.seed, self.m.fuzzed)
self.assertEqual(self.m.min_distance, 26)
for tsg in xrange(1, 20):
self.m.target_size_guess = tsg
self.m.set_discard_chance()
self.assertAlmostEqual(self.m.discard_chance, 1.0 / (1.0 + tsg))
def calculate_hamming_distances_a(self):
with open(self.fuzzedfile.path, 'rb') as fd:
fuzzed = fd.read()
a_string = 'x' * len(fuzzed)
self.hd_bits = hamming.bitwise_hd(a_string, fuzzed)
logger.info("crasher=%s bitwise_hd=%d", self.signature, self.hd_bits)
self.hd_bytes = hamming.bytewise_hd(a_string, fuzzed)
logger.info("crasher=%s bytewise_hd=%d", self.signature, self.hd_bytes)
def calculate_hamming_distances_a(self):
with open(self.fuzzedfile.path, 'rb') as fd:
fuzzed = fd.read()
a_string = 'x' * len(fuzzed)
self.hd_bits = hamming.bitwise_hd(a_string, fuzzed)
logger.info("crasher=%s bitwise_hd=%d", self.signature, self.hd_bits)
self.hd_bytes = hamming.bytewise_hd(a_string, fuzzed)
logger.info(
"crasher=%s bytewise_hd=%d", self.signature, self.hd_bytes)
def test_bytewise_hd(self):
s1 = "xxxxxxxxxxxxxx"
s2 = "12xx345xxxx678"
s3 = "000x00000xx00x"
self.assertEqual(bytewise_hd(s1, s2), 8)
self.assertEqual(bytewise_hd(s2, s3), 11)
self.assertEqual(bytewise_hd(s1, s3), 10)
self.assertEqual(bytewise_hd(s1, s1), 0)
self.assertEqual(bytewise_hd(s2, s2), 0)
self.assertEqual(bytewise_hd(s3, s3), 0)
# reject strings of different length
self.assertRaises(AssertionError, bytewise_hd, s1, s2 + "foo")
def test_bytewise_hd(self):
s1 = "xxxxxxxxxxxxxx"
s2 = "12xx345xxxx678"
s3 = "000x00000xx00x"
self.assertEqual(bytewise_hd(s1, s2), 8)
self.assertEqual(bytewise_hd(s2, s3), 11)
self.assertEqual(bytewise_hd(s1, s3), 10)
self.assertEqual(bytewise_hd(s1, s1), 0)
self.assertEqual(bytewise_hd(s2, s2), 0)
self.assertEqual(bytewise_hd(s3, s3), 0)
# reject strings of different length
self.assertRaises(AssertionError, bytewise_hd, s1, s2 + "foo")
def _test_fuzz(self, inputlen=1000, iterations=100, rangelist=None):
for i in xrange(iterations):
fuzzed = fuzz(fuzz_input=_input(inputlen),
seed_val=0,
jump_idx=i,
ratio_min=0.1,
ratio_max=0.3,
range_list=rangelist,
)
self.assertEqual(inputlen, len(fuzzed))
self._fail_if_not_fuzzed(fuzzed)
hd = bytewise_hd(_input(inputlen), fuzzed)
self.assertGreater(hd, 0)
self.assertLess(hd, inputlen)
actual_ratio = hd / float(inputlen)
self.assertGreaterEqual(actual_ratio, 0.1)
self.assertLessEqual(actual_ratio, 0.3)
