def __init__(self,
name,
default=b'',
path=CONFIG["GLOBALS"]["DEFAULT_STR_LIB"],
encoding=CONFIG["GLOBALS"]["CODEC"],
extra_encoding=None,
extra_encoding_data=None):
if isinstance(name, str) and name:
self.name = name
else:
raise DizzyParseException("Name must be str and not empty.")
self.default = default
if isinstance(default, Value):
self.list_ = [default]
elif isinstance(default, str):
self.list_ = [Value(default.encode(encoding))]
else:
self.list_ = [Value(default)]
self.path = path
self.flist_ = CONFIG["GLOBALS"]["GLOBAL_LIBRARY"].load_file(
path) #encoding?
self.extra_encoding = extra_encoding
self.extra_encoding_data = extra_encoding_data
def test_add_empty(self):
v1 = Value(b"", 0)
v2 = Value(b"\x01\x23", 10)
v3 = v1 + v2
self.assertEqual(v3.byte, b"\x01\x23")
self.assertEqual(v3.size, 10)
v3 = v2 + v1
self.assertEqual(v3.byte, b"\x01\x23")
self.assertEqual(v3.size, 10)
def test_add_aligned(self):
chars1 = b"This is a test "
chars2 = b"of adding adding aligned"
chars3 = b" values."
v1 = Value(chars1, len(chars1) * 8)
v2 = Value(chars2, len(chars2) * 8)
v3 = Value(chars3, len(chars3) * 8)
v4 = v1 + v2 + v3
self.assertEqual(v4.byte, chars1 + chars2 + chars3)
self.assertEqual(v4.size // 8, len(chars1) + len(chars2) + len(chars3))
def test_START_END(self):
objects = list()
objects.append(Field("test0", b"\x00"))
objects.append(Field("test1", b"\xff\xff"))
objects.append(Field("test2", b"\xaa"))
d = Dizz("test", objects, [length("test1", endian="<")], fuzz="std")
d_iter = iter(d)
next(d_iter)
self.assertEqual(d_iter[START], Value(b"\x00"))
self.assertEqual(d_iter["test1"], Value(b"\x20\x00"))
self.assertEqual(d_iter[END], Value(b"\xaa"))
def __setitem__(self, key, value):
if isinstance(value, int):
if not isinstance(key, str):
raise RuntimeError('%s: error during assignment' %
self) #Needz moar context
current_object = self.objects[key]
size = current_object.cur.size
value = Value(
value.to_bytes((size + 7) // 8,
endian_format[current_object.obj.endian]),
size) #Do Not Like
elif not isinstance(value, Value):
value = Value(value)
if isinstance(key, str):
if key == START:
key = self.state[0].obj.name
elif key == END:
key = self.state[-1].obj.name
self.objects[key].cur = value
elif isinstance(key, slice):
if not isinstance(key.start, str) or not isinstance(key.stop, str):
raise RuntimeError('Start and stop have to be str: %s' %
self.name)
if key.start == START:
start = self.state[0].obj.name
else:
start = key.start
if key.stop == END:
stop = self.state[-1].obj.name
else:
stop = key.stop
found = False
for cur in self.state:
if not found:
if cur.obj.name == start:
found = True
cur.cur = value
if key.start == stop:
return
else:
cur.cur = value
if cur.obj.name == stop:
return
if found:
raise DizzyParseException("Not found: %s" % (key.stop))
else:
raise DizzyParseException("Not found: %s:%s" %
(key.start, key.stop))
else:
raise RuntimeError('key has to be str or slice')
def test_add_unaligned(self):
v1 = Value(b"\x01\x23", 10)
v2 = Value(b"\x02", 2)
v3 = v1 + v2
self.assertEqual(v3.byte, b"\x04\x8e")
self.assertEqual(v3.size, 12)
v3 = v2 + v1
self.assertEqual(v3.byte, b"\x09\x23")
self.assertEqual(v3.size, 12)
v1 = Value(b'\x00\x00', 10)
v2 = Value(b'\x00\x1f\xf0\xff', 30)
v3 = v1 + v2
self.assertEqual(v3.byte, b'\x00\x00\x1f\xf0\xff')
self.assertEqual(v3.size, 40)
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size_in_bits = modulo - (dizzy_iterator[start:stop].size % modulo)
size_in_bytes = ((size_in_bits + 7) // 8)
dizzy_iterator[target] = Value(
urandom(size_in_bytes - 1) + size_in_bytes.to_bytes(1, 'big'),
size_in_bits)
def test_init(self):
objects = list()
objects.append(Field("test0", b"\x01\xff", 10, "std"))
objects.append(Field("test1", b"\xab", 8, "std"))
objects.append(Field("test2", b"\x00\xff", 12, "std"))
d = Dizz("test", objects, fuzz="none")
self.assertEqual(first(d), Value(b'\x1f\xfa\xb0\xff', 30))
def iter_full(self):
yield self.default
for r in range(self.size.start, self.size.stop, self.size.step):
i = 0
byte_length = (r + 7) // 8
max_value = 2**r
while i < max_value:
yield Value(i.to_bytes(byte_length, 'big'), r)
i += 1
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
mod = (dizzy_iterator[start:stop].size % modulo)
if mod > 0:
size_in_bits = modulo - mod
dizzy_iterator[target] = Value(
pattern * ((size_in_bits + 7) // 8), size_in_bits)
else:
dizzy_iterator[target] = ""
def enc_tree(node):
for i in node.down:
enc_tree(i)
(tag, _) = node.data.obj.extra_encoding_data
length = calc_len(node)
if length < 128:
len_octets = length.to_bytes(1, byteorder='big')
else:
len_bytes = length.bit_length() // 8
if length.bit_length() % 8 > 0:
len_bytes += 1
len_octets = (0x80 | len_bytes).to_bytes(
1, byteorder='big') + length.to_bytes(len_bytes, byteorder='big')
#print("tag: %s len: %s, len_octets: %s" % (tag.hex(), length, len_octets.hex()))
#print("old_cur: %s" % node.data.cur.byte.hex())
new_cur = Value(tag) + Value(len_octets) + node.data.cur
#print("new_cur: %s" % new_cur.byte.hex())
node.data.cur = new_cur
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size = dizzy_iterator[target].size
value = Value(
pack_with_length(dizzy_iterator[start:stop].size, size,
endian), size)
print_dizzy("length/%s: seting to %s." % (target, value), DEBUG)
dizzy_iterator[target] = value
else:
print_dizzy("length/%s: is not updated." % (target, ), DEBUG)
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size = str((dizzy_iterator[start:stop].size + 7) // 8)
value = Value(bytes(size, encoding), len(size) * 8)
print_dizzy(
"length_string_bytes/%s: seting to %s." % (target, value),
DEBUG)
dizzy_iterator[target] = value
else:
print_dizzy("length_string_bytes/%s: is not updated." % (target, ),
DEBUG)
def load_file(self, filename, listname=None):
if listname is None:
listname = filename
if listname in self.lib:
return self.lib[listname]
self.lib[listname] = []
with open(filename, 'r+b') as f:
for l in f:
if l.rstrip(b'\n') in self.lib[listname]:
pass
v = Value(l.rstrip(b'\n'))
self.lib[listname].append(v)
return self.lib[listname]
def __init__(self, name, size, count=1):
if isinstance(name, str) and name:
self.name = name
else:
raise DizzyParseException("Name must be str and not empty.")
self.list_ = list()
if isinstance(size, int):
size = slice(size, size + 1, 1)
for size_in_bits in range(size.start, size.stop, size.step):
size_in_bytes = (size_in_bits + 7) // 8
for y in range(count):
self.list_.append(Value(urandom(size_in_bytes), size_in_bits))
def get_current_state(self):
result = Value()
if not self.encoded:
apply_extra_encoding(self.state)
self.encoded = True
for a in self.state:
if not isinstance(a.cur, Value):
raise RuntimeError('Panic: cur has to be Value: %s' %
self.dizz)
result = result + a.cur
return StructuredValue(result, self)
def iter_std(self):
yield self.default
for r in range(self.size.start, self.size.stop, self.size.step):
if r > 2:
byte_length = (r + 7) // 8
for i in range(0, 5):
yield Value(i.to_bytes(byte_length, 'big'), r)
if r > 4:
buf = (2**r) - 1
for i in range(0, 5):
yield Value(
(buf - (4 - i)).to_bytes(byte_length, 'big'), r)
if r > 7:
buf = 2**(r - 1)
for i in range(0, 4):
yield Value(
(buf - (4 - i)).to_bytes(byte_length,
'big'), r)
if r > 8:
buf = 2**((byte_length - 1) * 8)
for i in range(1, 5):
yield Value(
(i * buf).to_bytes(byte_length, 'big'), r)
def test_eq(self):
v1 = Value(b"\x01\x23", 10)
v2 = Value(b"\x01\x23", 10)
v3 = Value(b"\x02", 2)
self.assertEqual(v1, v2)
self.assertNotEqual(v2, v3)
def test_iter(self):
expected = [Value(b'\x00""w3\x00!', 49), Value(b'\x00\x00\x00w3\x00!', 49), Value(b'\x00\x00\x02w3\x00!', 49),
Value(b'\x00\x00\x04w3\x00!', 49), Value(b'\x00\x00\x06w3\x00!', 49),
Value(b'\x00\x00\x08w3\x00!', 49), Value(b'\x01\xff\xf6w3\x00!', 49),
Value(b'\x01\xff\xf8w3\x00!', 49), Value(b'\x01\xff\xfaw3\x00!', 49),
Value(b'\x01\xff\xfcw3\x00!', 49), Value(b'\x01\xff\xfew3\x00!', 49),
Value(b'\x00\xff\xf8w3\x00!', 49), Value(b'\x00\xff\xfaw3\x00!', 49),
Value(b'\x00\xff\xfcw3\x00!', 49), Value(b'\x00\xff\xfew3\x00!', 49),
Value(b'\x00\x02\x00w3\x00!', 49), Value(b'\x00\x04\x00w3\x00!', 49),
Value(b'\x00\x06\x00w3\x00!', 49), Value(b'\x00\x08\x00w3\x00!', 49), Value(b'\x00""33\x00!', 49),
Value(b'\x00""33\x00!', 49), Value(b'\x00""73\x00!', 49), Value(b'\x00""73\x00!', 49),
Value(b'\x00"";3\x00!', 49), Value(b'\x00"#\xf73\x00!', 49), Value(b'\x00"#\xfb3\x00!', 49),
Value(b'\x00"#\xfb3\x00!', 49), Value(b'\x00"#\xff3\x00!', 49), Value(b'\x00"#\xff3\x00!', 49),
Value(b'\x00""\xfb3\x00!', 49), Value(b'\x00""\xfb3\x00!', 49), Value(b'\x00""\xff3\x00!', 49),
Value(b'\x00""\xff3\x00!', 49), Value(b'\x00""D\x00\x00!', 49), Value(b'\x00""D\x01\x00!', 49),
Value(b'\x00""D\x02\x00!', 49), Value(b'\x00""D\x03\x00!', 49), Value(b'\x00""D\x04\x00!', 49),
Value(b'\x00""E\xfb\x00!', 49), Value(b'\x00""E\xfc\x00!', 49), Value(b'\x00""E\xfd\x00!', 49),
Value(b'\x00""E\xfe\x00!', 49), Value(b'\x00""E\xff\x00!', 49), Value(b'\x00""D\xfc\x00!', 49),
Value(b'\x00""D\xfd\x00!', 49), Value(b'\x00""D\xfe\x00!', 49), Value(b'\x00""D\xff\x00!', 49),
Value(b'\x00""E\x00\x00!', 49), Value(b'\x00""F\x00\x00!', 49), Value(b'\x00""G\x00\x00!', 49),
Value(b'\x00""D\x00\x00!', 49), Value(b'\x00DD\x88\x00\x00"', 50),
Value(b'\x00DD\x88\x01\x00"', 50), Value(b'\x00DD\x88\x02\x00"', 50),
Value(b'\x00DD\x88\x03\x00"', 50), Value(b'\x00DD\x88\x04\x00"', 50),
Value(b'\x00DD\x8b\xfb\x00"', 50), Value(b'\x00DD\x8b\xfc\x00"', 50),
Value(b'\x00DD\x8b\xfd\x00"', 50), Value(b'\x00DD\x8b\xfe\x00"', 50),
Value(b'\x00DD\x8b\xff\x00"', 50), Value(b'\x00DD\x89\xfc\x00"', 50),
Value(b'\x00DD\x89\xfd\x00"', 50), Value(b'\x00DD\x89\xfe\x00"', 50),
Value(b'\x00DD\x89\xff\x00"', 50), Value(b'\x00DD\x89\x00\x00"', 50),
Value(b'\x00DD\x8a\x00\x00"', 50), Value(b'\x00DD\x8b\x00\x00"', 50),
Value(b'\x00DD\x8c\x00\x00"', 50), Value(b'\x00\x88\x89\x10\x00\x00#', 51),
Value(b'\x00\x88\x89\x10\x01\x00#', 51), Value(b'\x00\x88\x89\x10\x02\x00#', 51),
Value(b'\x00\x88\x89\x10\x03\x00#', 51), Value(b'\x00\x88\x89\x10\x04\x00#', 51),
Value(b'\x00\x88\x89\x17\xfb\x00#', 51), Value(b'\x00\x88\x89\x17\xfc\x00#', 51),
Value(b'\x00\x88\x89\x17\xfd\x00#', 51), Value(b'\x00\x88\x89\x17\xfe\x00#', 51),
Value(b'\x00\x88\x89\x17\xff\x00#', 51), Value(b'\x00\x88\x89\x13\xfc\x00#', 51),
Value(b'\x00\x88\x89\x13\xfd\x00#', 51), Value(b'\x00\x88\x89\x13\xfe\x00#', 51),
Value(b'\x00\x88\x89\x13\xff\x00#', 51), Value(b'\x00\x88\x89\x11\x00\x00#', 51),
Value(b'\x00\x88\x89\x12\x00\x00#', 51), Value(b'\x00\x88\x89\x13\x00\x00#', 51),
Value(b'\x00\x88\x89\x14\x00\x00#', 51), Value(b'\x01\x11\x12 \x00\x00$', 52),
Value(b'\x01\x11\x12 \x01\x00$', 52), Value(b'\x01\x11\x12 \x02\x00$', 52),
Value(b'\x01\x11\x12 \x03\x00$', 52), Value(b'\x01\x11\x12 \x04\x00$', 52),
Value(b'\x01\x11\x12/\xfb\x00$', 52), Value(b'\x01\x11\x12/\xfc\x00$', 52),
Value(b'\x01\x11\x12/\xfd\x00$', 52), Value(b'\x01\x11\x12/\xfe\x00$', 52),
Value(b'\x01\x11\x12/\xff\x00$', 52), Value(b"\x01\x11\x12'\xfc\x00$", 52),
Value(b"\x01\x11\x12'\xfd\x00$", 52), Value(b"\x01\x11\x12'\xfe\x00$", 52),
Value(b"\x01\x11\x12'\xff\x00$", 52), Value(b'\x01\x11\x12!\x00\x00$', 52),
Value(b'\x01\x11\x12"\x00\x00$', 52), Value(b'\x01\x11\x12#\x00\x00$', 52),
Value(b'\x01\x11\x12$\x00\x00$', 52), Value(b'\x02"$@\x00\x00%', 53),
Value(b'\x02"$@\x01\x00%', 53), Value(b'\x02"$@\x02\x00%', 53), Value(b'\x02"$@\x03\x00%', 53),
Value(b'\x02"$@\x04\x00%', 53), Value(b'\x02"$_\xfb\x00%', 53), Value(b'\x02"$_\xfc\x00%', 53),
Value(b'\x02"$_\xfd\x00%', 53), Value(b'\x02"$_\xfe\x00%', 53), Value(b'\x02"$_\xff\x00%', 53),
Value(b'\x02"$O\xfc\x00%', 53), Value(b'\x02"$O\xfd\x00%', 53), Value(b'\x02"$O\xfe\x00%', 53),
Value(b'\x02"$O\xff\x00%', 53), Value(b'\x02"$A\x00\x00%', 53), Value(b'\x02"$B\x00\x00%', 53),
Value(b'\x02"$C\x00\x00%', 53), Value(b'\x02"$D\x00\x00%', 53), Value(b'\x04DH\x80\x00\x00&', 54),
Value(b'\x04DH\x80\x01\x00&', 54), Value(b'\x04DH\x80\x02\x00&', 54),
Value(b'\x04DH\x80\x03\x00&', 54), Value(b'\x04DH\x80\x04\x00&', 54),
Value(b'\x04DH\xbf\xfb\x00&', 54), Value(b'\x04DH\xbf\xfc\x00&', 54),
Value(b'\x04DH\xbf\xfd\x00&', 54), Value(b'\x04DH\xbf\xfe\x00&', 54),
Value(b'\x04DH\xbf\xff\x00&', 54), Value(b'\x04DH\x9f\xfc\x00&', 54),
Value(b'\x04DH\x9f\xfd\x00&', 54), Value(b'\x04DH\x9f\xfe\x00&', 54),
Value(b'\x04DH\x9f\xff\x00&', 54), Value(b'\x04DH\x81\x00\x00&', 54),
Value(b'\x04DH\x82\x00\x00&', 54), Value(b'\x04DH\x83\x00\x00&', 54),
Value(b'\x04DH\x84\x00\x00&', 54), Value(b"\x08\x88\x91\x00\x00\x00'", 55),
Value(b"\x08\x88\x91\x00\x01\x00'", 55), Value(b"\x08\x88\x91\x00\x02\x00'", 55),
Value(b"\x08\x88\x91\x00\x03\x00'", 55), Value(b"\x08\x88\x91\x00\x04\x00'", 55),
Value(b"\x08\x88\x91\x7f\xfb\x00'", 55), Value(b"\x08\x88\x91\x7f\xfc\x00'", 55),
Value(b"\x08\x88\x91\x7f\xfd\x00'", 55), Value(b"\x08\x88\x91\x7f\xfe\x00'", 55),
Value(b"\x08\x88\x91\x7f\xff\x00'", 55), Value(b"\x08\x88\x91?\xfc\x00'", 55),
Value(b"\x08\x88\x91?\xfd\x00'", 55), Value(b"\x08\x88\x91?\xfe\x00'", 55),
Value(b"\x08\x88\x91?\xff\x00'", 55), Value(b"\x08\x88\x91\x01\x00\x00'", 55),
Value(b"\x08\x88\x91\x02\x00\x00'", 55), Value(b"\x08\x88\x91\x03\x00\x00'", 55),
Value(b"\x08\x88\x91\x04\x00\x00'", 55), Value(b'\x11\x11"\x00\x00\x00(', 56),
Value(b'\x11\x11"\x00\x01\x00(', 56), Value(b'\x11\x11"\x00\x02\x00(', 56),
Value(b'\x11\x11"\x00\x03\x00(', 56), Value(b'\x11\x11"\x00\x04\x00(', 56),
Value(b'\x11\x11"\xff\xfb\x00(', 56), Value(b'\x11\x11"\xff\xfc\x00(', 56),
Value(b'\x11\x11"\xff\xfd\x00(', 56), Value(b'\x11\x11"\xff\xfe\x00(', 56),
Value(b'\x11\x11"\xff\xff\x00(', 56), Value(b'\x11\x11"\x7f\xfc\x00(', 56),
Value(b'\x11\x11"\x7f\xfd\x00(', 56), Value(b'\x11\x11"\x7f\xfe\x00(', 56),
Value(b'\x11\x11"\x7f\xff\x00(', 56), Value(b'\x11\x11"\x01\x00\x00(', 56),
Value(b'\x11\x11"\x02\x00\x00(', 56), Value(b'\x11\x11"\x03\x00\x00(', 56),
Value(b'\x11\x11"\x04\x00\x00(', 56), Value(b'\x00""w3\x00\x00', 49),
Value(b'\x00""w3\x00\x01', 49), Value(b'\x00""w3\x00\x02', 49), Value(b'\x00""w3\x00\x03', 49),
Value(b'\x00""w3\x00\x04', 49), Value(b'\x00""w3\xff\xfb', 49), Value(b'\x00""w3\xff\xfc', 49),
Value(b'\x00""w3\xff\xfd', 49), Value(b'\x00""w3\xff\xfe', 49), Value(b'\x00""w3\xff\xff', 49),
Value(b'\x00""w3\x7f\xfc', 49), Value(b'\x00""w3\x7f\xfd', 49), Value(b'\x00""w3\x7f\xfe', 49),
Value(b'\x00""w3\x7f\xff', 49), Value(b'\x00""w3\x01\x00', 49), Value(b'\x00""w3\x02\x00', 49),
Value(b'\x00""w3\x03\x00', 49), Value(b'\x00""w3\x04\x00', 49)]
objects = list()
objects.append(Field("test0", b"\x11\x11", fuzz="std"))
objects.append(Field("test1", b"\x22", fuzz="std"))
objects.append(Field("test2", b"\x33\x33", slice(9, 17), fuzz="std"))
objects.append(Field("length", b"\x00\x00", fuzz="std"))
functions = list()
functions.append(length("length", "test0", "test2"))
d = Dizz("test", objects, functions, fuzz="std")
self.assertEqual([i for i in d], expected)
def test_import(self):
expected = [Value(b'\n\xed\xcc', 20), Value(b'\x02\xed\xcc', 20), Value(b'\x06\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\x0e\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xec\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xee\xcc', 20), Value(b'\n\xef\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20), Value(b'\n\xed\xcc', 20),
Value(b'\n\xed\xcc', 20)]
objects = list()
objects.append(Field("test0", b"\x01", 2, "full"))
objects.append(Field("test1", b"\xff", 8, "std"))
def func1(dizzy_iterator):
dizzy_iterator["test1"] = b"\xaa"
d1 = Dizz("test_import", objects, [(func1, BOTH)], fuzz="std")
objects = list()
objects.append(Field("test0", b"\x02", 2, "full"))
objects.append(Field("test1", b"\xff", 8, "std"))
objects.append(d1)
def func0(dizzy_iterator):
dizzy_iterator["test1"] = b"\xbb"
dizzy_iterator["test_import"]["test1"] = b"\xcc"
d0 = Dizz("test", objects, [(func0, BOTH)], fuzz="std")
self.assertEqual(list(d0), expected)
def test_load(self):
expected = Value(b'\x00\x00\x00\x00\x00\n\x18\x00\x00\x00', 80)
d = load_dizz("test", "modules_src/demo/demo/dizz/demo.dizz")
self.assertEqual(first(d), expected)
def func(dizzy_iterator):
size_in_bits = dizzy_iterator[target].size
dizzy_iterator[target] = Value(urandom((size_in_bits + 7) // 8),
size_in_bits)
def inc(interaction_iterator, dizzy_iterator, response):
i = int.from_bytes(dizzy_iterator["test2"].byte, "big") + 1
dizzy_iterator["test2"] = Value(i.to_bytes(2, "big"))
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size_in_bits = modulo - (dizzy_iterator[start:stop].size % modulo)
size_in_bytes = ((size_in_bits + 7) // 8)
dizzy_iterator[target] = Value(
b"\x80" + (size_in_bytes - 1) * b"\x00", size_in_bits)
def test_iter(self):
expected = [
Value(b'\x01#', 10),
Value(b'\x00\x00', 10),
Value(b'\x00\x01', 10),
Value(b'\x00\x02', 10),
Value(b'\x00\x03', 10),
Value(b'\x00\x04', 10),
Value(b'\x03\xfb', 10),
Value(b'\x03\xfc', 10),
Value(b'\x03\xfd', 10),
Value(b'\x03\xfe', 10),
Value(b'\x03\xff', 10),
Value(b'\x01\xfc', 10),
Value(b'\x01\xfd', 10),
Value(b'\x01\xfe', 10),
Value(b'\x01\xff', 10),
Value(b'\x01\x00', 10),
Value(b'\x02\x00', 10),
Value(b'\x03\x00', 10),
Value(b'\x04\x00', 10)
]
f = Field("test", b"\x01\x23", 10, "std")
self.assertEqual([i for i in f], expected)
def test_init(self):
f = Field("test", b"\x01\x23", slice(10, 12), "std")
self.assertEqual(f.name, "test")
self.assertEqual(f.size, slice(10, 12, 1))
self.assertEqual(f.default, Value(b"\x01\x23", 10))
self.assertEqual(f.fuzz, "std")
def __iter__(self):
for string in generate(self.regex, self.limit):
value = bytes(string, encoding=CONFIG["GLOBALS"]["CODEC"])
yield Value(value, len(value) * 8)
def __init__(self,
name,
default=b'',
size=None,
fuzz='none',
endian="!",
encoding=CONFIG["GLOBALS"]["CODEC"],
extra_encoding=None,
extra_encoding_data=None):
if isinstance(name, str) and name:
self.name = name
else:
raise DizzyParseException("Name must be str and not empty.")
self.encoding = encoding
self.extra_encoding = extra_encoding
self.extra_encoding_data = extra_encoding_data
if isinstance(default, str):
self.default = bytes(default, self.encoding)
elif isinstance(default, bytes):
self.default = default
elif isinstance(default, int):
# TODO: check size type
self.default = pack_with_length(default, size, endian)
else:
raise DizzyParseException('Default must be str, bytes or int: %s' %
name)
if isinstance(size, int):
self.size = slice(size, size + 1, 1)
elif size is None:
self.size = len(self.default) * 8
self.size = slice(self.size, self.size + 1, 1)
elif isinstance(size, slice):
self.size = size
else:
raise DizzyParseException("Unknown fuzzing mode: %s" % name)
if self.size.start < 0:
raise DizzyParseException(
'Length less than 0 are not allowed: %s' % name)
elif self.size.stop <= self.size.start:
raise DizzyParseException(
'Length less than 0 are not allowed: %s' % name)
elif self.size.step is None:
self.size = slice(self.size.start, self.size.stop, 1)
elif self.size.step <= 0:
raise DizzyParseException('Step must not be 0: %s' % name)
self.fuzz = fuzz
if self.fuzz == "full":
if self.size.start > maxsize or self.size.stop > maxsize:
raise DizzyParseException(
"Cannot make dizzy with length '%d' full fuzzable, "
"this would take ages: %s" % (size, name))
else:
self.iter = self.iter_full
self.len = 1
for r in range(self.size.start, self.size.stop,
self.size.step):
self.len += 2**r
elif self.fuzz == 'std':
self.iter = self.iter_std
self.len = 1
for r in range(self.size.start, self.size.stop, self.size.step):
if r > 2:
self.len += 5
if r > 4:
self.len += 5
if r > 7:
self.len += 4
if r > 8:
self.len += 4
elif self.fuzz is 'none':
self.iter = self.iter_none
self.len = 1
else:
raise DizzyParseException("Unknown fuzzing mode: %s" % name)
self.default = Value(self.default, self.size.start)
self.endian = endian
def test_init(self):
v = Value(b"\x01\x23", 10)
self.assertEqual(v.byte, b"\x01\x23")
self.assertEqual(v.size, 10)
