def assert_block32_bytes_packing(data_bytes): orig = to_bytes(data_bytes) extra_bytes = to_bytes('dummy-start') + orig + to_bytes('dummy-end') unpacked, remaining = util.block32_lv_bytes_unpack_rolling( util.block32_lv_bytes_pack(orig) + extra_bytes) assert unpacked == orig assert remaining == extra_bytes
def test_to_bytes(): assert 'abc' == to_bytes('abc') assert 'abc' == to_bytes([97, 98, 99]) if util.is_python2(): assert str('abc') == to_bytes('abc') if util.is_python3(): assert bytes([97, 98, 99]) == to_bytes([97, 98, 99])
def assert_block32_labelled_bytes_packing(data_bytes): orig = to_bytes(data_bytes) extra_bytes = to_bytes('dummy-start') + orig + to_bytes('dummy-end') label, unpacked, remaining = util.block32_tlv_bytes_unpack_rolling( util.block32_tlv_bytes_pack(block_label, orig) + extra_bytes) assert label == block_label assert unpacked == orig assert remaining == extra_bytes
def pack(self): #todo needs test "Serialize to packed bytes" content = to_bytes(self.addr_bytes) + to_bytes([self.prefix_len]) content_len = len(content) assert content_len == 17 content_pad = util.block32_pad_bytes(content) packed_bytes = struct.pack('=HH', self.type_code, content_len) + content_pad util.assert_block32_length(packed_bytes) #todo add to all return packed_bytes
def __init__(self, interface_id, pkt_data_captured, pkt_data_orig_len=None, options_lst=[], timestamp=None): """Creates an EPB object. If 'timestamp' is not supplied, uses the current UTC time in the default format (uint64 microseconds since unix epoch). User-supplied timestamp must also be in this format unless IDB options uses option.IdbTsResol to specify alternate.""" util.assert_uint32(interface_id) #todo verify args in all fns pkt_data_captured = to_bytes( pkt_data_captured) #todo is list & tuple & str ok? if pkt_data_orig_len is None: pkt_data_orig_len = len(pkt_data_captured) else: util.assert_uint32(pkt_data_orig_len) assert len(pkt_data_captured) <= pkt_data_orig_len util.assert_type_list(options_lst) #todo check type on all fns for opt in options_lst: assert self.is_epb_option(opt) if timestamp is None: time_utc_micros = util.curr_time_utc_micros() else: time_utc_micros = timestamp self.interface_id = interface_id self.pkt_data_captured = pkt_data_captured self.pkt_data_orig_len = pkt_data_orig_len self.options_lst = options_lst self.time_utc_micros = time_utc_micros
def assert_cmib_codec(content): content_bytes = to_bytes(content) cmib_obj = block.CustomMrtIsisBlock(content_bytes) mrt_info = block.CustomMrtIsisBlock.unpack(cmib_obj.pack()) assert mrt_info['mrt_type'] == mrt.ISIS assert mrt_info['mrt_subtype'] == 0 assert mrt_info['content'] == content_bytes
def pack(self): "Serialize to packed bytes" content = to_bytes(self.addr_bytes) content_len = len(content) assert content_len == 8 packed_bytes = add_header(self.type_code, content_len, content) return packed_bytes
def get_dummy_pkt(): global pkt_len_curr, pkt_len_min, pkt_len_max next_len = pkt_len_curr + 1 if (pkt_len_min <= next_len <= pkt_len_max): pkt_len_curr = next_len else: pkt_len_curr = pkt_len_min result = to_bytes(range(pkt_len_min, pkt_len_curr + 1)) return result
def test_EpbFlags(): content = to_bytes([1, 2, 3, 4]) c1 = option.EpbFlags(content) packed_bytes = c1.pack() c1u = option.EpbFlags.unpack(packed_bytes) assert len(packed_bytes) == 8 #todo add this test everywhere assert c1.content == c1u.content == content assert util.classname(c1) == util.classname( c1u) == 'pcapng.option.EpbFlags'
def pack(self): """Serialize an CB object into packed bytes. NOTE: We are required to use Length-Value (LV) encoding for the custom content so that any options may also be recovered.""" content_bytes = util.block32_lv_bytes_pack(to_bytes(self.content)) options_bytes = option.pack_all(self.options_lst) block_total_len = 16 + len(content_bytes) + len(options_bytes) packed_bytes = (struct.pack(self.head_encoding, self.block_type, block_total_len, self.pen_val) + content_bytes + options_bytes + struct.pack(self.tail_encoding, block_total_len)) return packed_bytes
def assert_epb_codec(interface_id, pkt_data, pkt_data_orig_len=None, options_lst=[]): pkt_data = to_bytes(pkt_data) if pkt_data_orig_len is None: pkt_data_orig_len = len( pkt_data) #todo does not test None or invalid val epb_obj = block.EnhancedPacketBlock(interface_id, pkt_data, pkt_data_orig_len, options_lst) epb_bytes = epb_obj.pack() epb_obj_unpacked = block.EnhancedPacketBlock.unpack(epb_bytes) assert util.classname( epb_obj_unpacked) == 'pcapng.block.EnhancedPacketBlock' assert epb_obj_unpacked == epb_obj
def test_pad_to_block32(): assert to_bytes([]) == util.block32_pad_bytes([]) assert to_bytes([1, 0, 0, 0]) == util.block32_pad_bytes([1]) assert to_bytes([1, 2, 0, 0]) == util.block32_pad_bytes([1, 2]) assert to_bytes([1, 2, 3, 0]) == util.block32_pad_bytes([1, 2, 3]) assert to_bytes([1, 2, 3, 4]) == util.block32_pad_bytes([1, 2, 3, 4]) assert to_bytes([1, 2, 3, 4, 5, 0, 0, 0]) == util.block32_pad_bytes([1, 2, 3, 4, 5]) assert to_bytes([1, 2, 3, 4, 5, 6, 0, 0]) == util.block32_pad_bytes([1, 2, 3, 4, 5, 6]) assert to_bytes([1, 2, 3, 4, 5, 6, 7, 0]) == util.block32_pad_bytes([1, 2, 3, 4, 5, 6, 7]) assert to_bytes([1, 2, 3, 4, 5, 6, 7, 8]) == util.block32_pad_bytes([1, 2, 3, 4, 5, 6, 7, 8]) util.assert_block32_length([]) util.assert_block32_length([1, 2, 3, 4]) util.assert_block32_length([1, 2, 3, 4, 5, 6, 7, 8]) with pytest.raises(AssertionError): util.assert_block32_length([1]) with pytest.raises(AssertionError): util.assert_block32_length([1, 2]) with pytest.raises(AssertionError): util.assert_block32_length([1, 2, 3])
def assert_custom_block_codec(content_bytes): opts = [ option.CustomStringCopyable(pen.BROCADE_PEN, "O"), option.CustomBinaryCopyable(pen.BROCADE_PEN, "Doh!"), option.CustomStringNonCopyable(pen.BROCADE_PEN, "Release the hounds!"), option.CustomBinaryNonCopyable(pen.BROCADE_PEN, [1, 2, 3]) ] orig = to_bytes(content_bytes) cbc_obj = block.CustomBlockCopyable(pen.BROCADE_PEN, orig, opts) cbc_bytes = cbc_obj.pack() cbc_obj_unpack = block.CustomBlockCopyable.unpack(cbc_bytes) assert cbc_obj_unpack == cbc_obj cbnc_obj = block.CustomBlockNonCopyable(pen.BROCADE_PEN, orig, opts) cbnc_bytes = cbnc_obj.pack() cbnc_obj_unpack = block.CustomBlockNonCopyable.unpack(cbnc_bytes) print print('770', cbnc_obj) print('771', cbnc_obj_unpack) assert cbnc_obj_unpack == cbnc_obj
def __init__(self, pen_val, content): "Create a PCAPNG Custom String Copyable Option" pen.assert_valid_pen(pen_val) self.type_code = self.SPEC_CODE self.pen_val = pen_val self.content = to_bytes(content)
def test_pad_to_len(): with pytest.raises(AssertionError): util.pad_bytes([1, 2, 3, 4], 3) with pytest.raises(AssertionError): util.pad_bytes('superlong', 3) assert to_bytes('superlong' + chr(0) * 23) == util.pad_bytes( 'superlong', 32) assert to_bytes([0, 0, 0, 0]) == util.pad_bytes([], 4) assert to_bytes([1, 0, 0, 0]) == util.pad_bytes([ 1, ], 4) assert to_bytes([1, 2, 0, 0]) == util.pad_bytes([1, 2], 4) assert to_bytes([1, 2, 3, 0]) == util.pad_bytes([1, 2, 3], 4) assert to_bytes([1, 2, 3, 4]) == util.pad_bytes([1, 2, 3, 4], 4) assert to_bytes([9, 9, 9, 9]) == util.pad_bytes([], 4, 9) assert to_bytes([1, 9, 9, 9]) == util.pad_bytes([ 1, ], 4, 9) assert to_bytes([1, 2, 9, 9]) == util.pad_bytes([1, 2], 4, 9) assert to_bytes([1, 2, 3, 9]) == util.pad_bytes([1, 2, 3], 4, 9) assert to_bytes([1, 2, 3, 4]) == util.pad_bytes([1, 2, 3, 4], 4, 9)
def __init__(self, pkt_data): "Creates an SPB object" self.pkt_data = to_bytes(pkt_data) #todo is list & tuple & str ok?
def __init__(self, type_code, content): "Creates an Option block" #todo assert valid type_code? self.type_code = type_code self.content = to_bytes(content)
def __init__(self, pkt_data): "Creates an ISIS MRT Block object" self.pkt_data = to_bytes(pkt_data)
def __init__(self, pen_val, content): "Create an instance" pen.assert_valid_pen(pen_val) self.type_code = self.SPEC_CODE self.pen_val = pen_val self.content = to_bytes(content)
def pack(self): #todo needs test "Serialize to packed bytes" packed_bytes = (struct.pack('=HH', self.type_code, 8) + to_bytes(self.addr_bytes) + to_bytes(self.netmask_bytes)) return packed_bytes
def assert_option_codec(type_code, opt_value): opt = option.Option(type_code, opt_value) opt_unpacked = option.Option.unpack(opt.pack()) assert opt.type_code == type_code assert opt.content == to_bytes(opt_value) assert opt == opt_unpacked
def test_str_to_bytes(): assert to_bytes([97, 98, 99]) == str_to_bytes('abc')
def test_EpbHash(): content = to_bytes("<generic hash spec here>") c1 = option.EpbHash(content) c1u = option.EpbHash.unpack(c1.pack()) assert c1.content == c1u.content == content assert util.classname(c1) == util.classname(c1u) == 'pcapng.option.EpbHash'
def __init__(self, content): "Create an instance" content = to_bytes(content) assert len(content) == 4 EpbOption.__init__(self, self.SPEC_CODE, content)
def string_utf8_pack(str_val): content = to_bytes(str_val) packed_bytes = util.block32_pad_bytes( struct.pack('=HH', STRING_UTF8, len(content)) + content) return packed_bytes