def test_little_endian_16_bit(self):
mb = MessageTypeBuilder("little_endian_16_length_test")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 16)
num_messages_by_data_length = {256 * 8: 5, 16: 4, 512: 2}
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"},
little_endian=True)
random.seed(0)
for data_length, num_messages in num_messages_by_data_length.items():
for i in range(num_messages):
pg.generate_message(data="".join(
[random.choice(["0", "1"]) for _ in range(data_length)]))
#self.save_protocol("little_endian_16_length_test", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
length_engine = LengthEngine(ff.bitvectors)
highscored_ranges = length_engine.find(n_gram_length=8)
self.assertEqual(len(highscored_ranges), 3)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertGreater(len(ff.message_types[0]), 0)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.LENGTH)
self.assertEqual(label.start, 24)
self.assertEqual(label.length, 16)
def test_format_finding_enocean(self):
enocean_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("enocean_bits.txt")) as f:
for line in f:
enocean_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
enocean_protocol.messages[-1].message_type = enocean_protocol.default_message_type
preamble_start = 3
preamble_end = 10
sof_start = 11
sof_end = 14
preamble_label = ProtocolLabel(name=self.preamble_field_type.caption, field_type=self.preamble_field_type,
start=preamble_start, end=preamble_end, color_index=0)
sync_label = ProtocolLabel(name=self.sync_field_type.caption, field_type=self.sync_field_type,
start=sof_start, end=sof_end, color_index=1)
ff = FormatFinder(enocean_protocol, self.participants, field_types=self.field_types)
ff.perform_iteration()
self.assertEqual(len(enocean_protocol.message_types), 1)
self.assertIn(preamble_label, enocean_protocol.default_message_type)
self.assertIn(sync_label, enocean_protocol.default_message_type)
self.assertTrue(
not any(lbl.name == self.length_field_type.caption for lbl in enocean_protocol.default_message_type))
self.assertTrue(not any("address" in lbl.name.lower() for lbl in enocean_protocol.default_message_type))
def test_given_address_information(self):
"""
Empty both message types and see if addresses are found, when information of participant addresses is given
:return:
"""
protocol = self.__prepare_example_protocol()
self.clear_message_types(protocol.messages)
ff = FormatFinder(protocol.messages)
ff.perform_iteration()
self.assertEqual(2, len(ff.message_types))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.PREAMBLE))
self.assertIsNotNone(ff.message_types[1].get_first_label_with_type(
FieldType.Function.PREAMBLE))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.SYNC))
self.assertIsNotNone(ff.message_types[1].get_first_label_with_type(
FieldType.Function.SYNC))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.LENGTH))
self.assertIsNotNone(ff.message_types[1].get_first_label_with_type(
FieldType.Function.LENGTH))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.DST_ADDRESS))
self.assertIsNotNone(ff.message_types[1].get_first_label_with_type(
FieldType.Function.DST_ADDRESS))
self.assertIsNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.SRC_ADDRESS))
self.assertIsNotNone(ff.message_types[1].get_first_label_with_type(
FieldType.Function.SRC_ADDRESS))
def test_sequence_number_little_endian_16_bit(self):
mb = MessageTypeBuilder("16bit_seq_test")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.SEQUENCE_NUMBER, 16)
num_messages = 8
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"},
little_endian=True,
sequence_number_increment=64)
for i in range(num_messages):
pg.generate_message(data="0xcafe")
#self.save_protocol("16bit_litte_endian_seq", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertEqual(
ff.message_types[0].num_labels_with_type(
FieldType.Function.SEQUENCE_NUMBER), 1)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.SEQUENCE_NUMBER)
self.assertEqual(label.start, 24)
self.assertEqual(label.length, 16)
def test_format_finding_enocean(self):
enocean_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("enocean_bits.txt")) as f:
for line in f:
enocean_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
enocean_protocol.messages[-1].message_type = enocean_protocol.default_message_type
ff = FormatFinder(enocean_protocol.messages)
ff.perform_iteration()
message_types = ff.message_types
self.assertEqual(len(message_types), 1)
preamble = message_types[0].get_first_label_with_type(FieldType.Function.PREAMBLE)
self.assertEqual(preamble.start, 0)
self.assertEqual(preamble.length, 8)
sync = message_types[0].get_first_label_with_type(FieldType.Function.SYNC)
self.assertEqual(sync.start, 8)
self.assertEqual(sync.length, 4)
checksum = message_types[0].get_first_label_with_type(FieldType.Function.CHECKSUM)
self.assertEqual(checksum.start, 56)
self.assertEqual(checksum.length, 4)
self.assertIsNone(message_types[0].get_first_label_with_type(FieldType.Function.SRC_ADDRESS))
self.assertIsNone(message_types[0].get_first_label_with_type(FieldType.Function.DST_ADDRESS))
self.assertIsNone(message_types[0].get_first_label_with_type(FieldType.Function.LENGTH))
self.assertIsNone(message_types[0].get_first_label_with_type(FieldType.Function.SEQUENCE_NUMBER))
def auto_assign_labels(self):
if len(self.used_symbols) > 0:
logger.info("Format Finder not compatible with symbols yet.")
return
format_finder = FormatFinder(self)
# OPEN: Perform multiple iterations with varying priorities later
format_finder.perform_iteration()
def test_homematic(self):
proto_file = get_path_for_data_file("homematic.proto.xml")
protocol = ProtocolAnalyzer(signal=None, filename=proto_file)
protocol.message_types = []
protocol.from_xml_file(filename=proto_file, read_bits=True)
# prevent interfering with preassinged labels
protocol.message_types = [MessageType("Default")]
participants = sorted({msg.participant for msg in protocol.messages})
self.clear_message_types(protocol.messages)
ff = FormatFinder(protocol.messages, participants=participants)
ff.known_participant_addresses.clear()
ff.perform_iteration()
self.assertGreater(len(ff.message_types), 0)
for i, message_type in enumerate(ff.message_types):
preamble = message_type.get_first_label_with_type(FieldType.Function.PREAMBLE)
self.assertEqual(preamble.start, 0)
self.assertEqual(preamble.length, 32)
sync = message_type.get_first_label_with_type(FieldType.Function.SYNC)
self.assertEqual(sync.start, 32)
self.assertEqual(sync.length, 32)
length = message_type.get_first_label_with_type(FieldType.Function.LENGTH)
self.assertEqual(length.start, 64)
self.assertEqual(length.length, 8)
seq = message_type.get_first_label_with_type(FieldType.Function.SEQUENCE_NUMBER)
self.assertEqual(seq.start, 72)
self.assertEqual(seq.length, 8)
src = message_type.get_first_label_with_type(FieldType.Function.SRC_ADDRESS)
self.assertEqual(src.start, 96)
self.assertEqual(src.length, 24)
dst = message_type.get_first_label_with_type(FieldType.Function.DST_ADDRESS)
self.assertEqual(dst.start, 120)
self.assertEqual(dst.length, 24)
checksum = message_type.get_first_label_with_type(FieldType.Function.CHECKSUM)
self.assertEqual(checksum.length, 16)
self.assertIn("CC1101", checksum.checksum.caption)
for msg_index in ff.existing_message_types[message_type]:
msg_len = len(protocol.messages[msg_index])
self.assertEqual(checksum.start, msg_len-16)
self.assertEqual(checksum.end, msg_len)
def test_fully_labeled(self):
"""
For fully labeled protocol, nothing should be done
:return:
"""
protocol = self.__prepare_example_protocol()
message_types = sorted(copy.deepcopy(protocol.message_types),
key=lambda x: x.name)
ff = FormatFinder(protocol.messages)
ff.perform_iteration()
self.assertEqual(len(message_types), len(ff.message_types))
for mt1, mt2 in zip(message_types, ff.message_types):
self.assertTrue(self.__message_types_have_same_labels(mt1, mt2))
def test_medium_protocol(self):
"""
Protocol with two message types. Length field only present in one of them
:return:
"""
mb1 = MessageTypeBuilder("data")
mb1.add_label(FieldType.Function.PREAMBLE, 8)
mb1.add_label(FieldType.Function.SYNC, 8)
mb1.add_label(FieldType.Function.LENGTH, 8)
mb1.add_label(FieldType.Function.SEQUENCE_NUMBER, 8)
mb2 = MessageTypeBuilder("ack")
mb2.add_label(FieldType.Function.PREAMBLE, 8)
mb2.add_label(FieldType.Function.SYNC, 8)
pg = ProtocolGenerator([mb1.message_type, mb2.message_type],
syncs_by_mt={
mb1.message_type: "11110011",
mb2.message_type: "11110011"
})
num_messages_by_data_length = {8: 5, 16: 10, 32: 5}
for data_length, num_messages in num_messages_by_data_length.items():
for i in range(num_messages):
pg.generate_message(data=pg.decimal_to_bits(
10 * i, data_length),
message_type=mb1.message_type)
pg.generate_message(message_type=mb2.message_type, data="0xaf")
#self.save_protocol("medium_length", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 2)
length_mt = next(mt for mt in ff.message_types
if mt.get_first_label_with_type(
FieldType.Function.LENGTH) is not None)
length_label = length_mt.get_first_label_with_type(
FieldType.Function.LENGTH)
for i, sync_end in enumerate(ff.sync_ends):
self.assertEqual(sync_end, 16, msg=str(i))
self.assertEqual(16, length_label.start)
self.assertEqual(8, length_label.length)
def test_easy_protocol(self):
"""
preamble, sync, sequence number, length field (8 bit) and some random data
:return:
"""
mb = MessageTypeBuilder("easy_length_test")
mb.add_label(FieldType.Function.PREAMBLE, 16)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 8)
mb.add_label(FieldType.Function.SEQUENCE_NUMBER, 8)
num_messages_by_data_length = {32: 10, 64: 15, 16: 5, 24: 7}
pg = ProtocolGenerator([mb.message_type],
preambles_by_mt={mb.message_type: "10" * 8},
syncs_by_mt={mb.message_type: "0xcafe"})
for data_length, num_messages in num_messages_by_data_length.items():
for i in range(num_messages):
if i % 4 == 0:
data = "1" * data_length
elif i % 4 == 1:
data = "0" * data_length
elif i % 4 == 2:
data = "10" * (data_length // 2)
else:
data = "01" * (data_length // 2)
pg.generate_message(data=data)
#self.save_protocol("easy_length", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
length_engine = LengthEngine(ff.bitvectors)
highscored_ranges = length_engine.find(n_gram_length=8)
self.assertEqual(len(highscored_ranges), 4)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertGreater(len(ff.message_types[0]), 0)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.LENGTH)
self.assertIsInstance(label, ProtocolLabel)
self.assertEqual(label.start, 32)
self.assertEqual(label.length, 8)
def test_one_message_type_empty(self):
"""
Empty the "ACK" message type, the labels should be find by FormatFinder
:return:
"""
protocol = self.__prepare_example_protocol()
n_message_types = len(protocol.message_types)
ack_mt = next(mt for mt in protocol.message_types if mt.name == "ack")
ack_mt.clear()
self.assertEqual(len(ack_mt), 0)
ff = FormatFinder(protocol.messages)
ff.perform_iteration()
self.assertEqual(n_message_types, len(ff.message_types))
self.assertEqual(len(ack_mt), 4, msg=str(ack_mt))
def test_no_sequence_number(self):
"""
Ensure no sequence number is labeled, when it cannot be found
:return:
"""
alice = Participant("Alice", address_hex="dead")
bob = Participant("Bob", address_hex="beef")
mb = MessageTypeBuilder("protocol_with_one_message_type")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 8)
mb.add_label(FieldType.Function.SRC_ADDRESS, 16)
mb.add_label(FieldType.Function.DST_ADDRESS, 16)
num_messages = 3
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x1337"},
participants=[alice, bob])
for i in range(num_messages):
if i % 2 == 0:
source, destination = alice, bob
else:
source, destination = bob, alice
pg.generate_message(data="",
source=source,
destination=destination)
#self.save_protocol("protocol_1", pg)
# Delete message type information -> no prior knowledge
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
ff.known_participant_addresses.clear()
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertEqual(
ff.message_types[0].num_labels_with_type(
FieldType.Function.SEQUENCE_NUMBER), 0)
def test_format_finding_rwe(self):
preamble_start, preamble_end = 0, 31
sync_start, sync_end = 32, 63
length_start, length_end = 64, 71
ack_address_start, ack_address_end = 72, 95
dst_address_start, dst_address_end = 88, 111
src_address_start, src_address_end = 112, 135
preamble_label = ProtocolLabel(name=self.preamble_field_type.caption, field_type=self.preamble_field_type,
start=preamble_start, end=preamble_end, color_index=0)
sync_label = ProtocolLabel(name=self.sync_field_type.caption, field_type=self.sync_field_type,
start=sync_start, end=sync_end, color_index=1)
length_label = ProtocolLabel(name=self.length_field_type.caption, field_type=self.length_field_type,
start=length_start, end=length_end, color_index=2)
ack_address_label = ProtocolLabel(name=self.dst_address_field_type.caption,
field_type=self.dst_address_field_type,
start=ack_address_start, end=ack_address_end, color_index=3)
dst_address_label = ProtocolLabel(name=self.dst_address_field_type.caption,
field_type=self.dst_address_field_type,
start=dst_address_start, end=dst_address_end, color_index=4)
src_address_label = ProtocolLabel(name=self.src_address_field_type.caption,
field_type=self.src_address_field_type,
start=src_address_start, end=src_address_end, color_index=5)
ff = FormatFinder(protocol=self.protocol, participants=self.participants, field_types=self.field_types)
ff.perform_iteration()
self.assertIn(preamble_label, self.protocol.default_message_type)
self.assertIn(sync_label, self.protocol.default_message_type)
self.assertIn(length_label, self.protocol.default_message_type)
self.assertIn(dst_address_label, self.protocol.default_message_type)
self.assertIn(src_address_label, self.protocol.default_message_type)
self.assertEqual(len(self.protocol.message_types), 2)
self.assertEqual(self.protocol.message_types[1].name, "ack")
self.assertIn(ack_address_label, self.protocol.message_types[1])
ack_messages = (1, 3, 5, 7, 9, 11, 13, 15, 17, 20)
for i, msg in enumerate(self.protocol.messages):
if i in ack_messages:
self.assertEqual(msg.message_type.name, "ack", msg=i)
else:
self.assertEqual(msg.message_type.name.lower(), "default", msg=i)
def test_type_part_already_labeled(self):
protocol = self.__prepare_simple_example_protocol()
self.clear_message_types(protocol.messages)
ff = FormatFinder(protocol.messages)
# overlaps type
ff.message_types[0].add_protocol_label_start_length(32, 8)
ff.perform_iteration()
self.assertEqual(1, len(ff.message_types))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.PREAMBLE))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.SYNC))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.LENGTH))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.DST_ADDRESS))
self.assertIsNotNone(ff.message_types[0].get_first_label_with_type(
FieldType.Function.SRC_ADDRESS))
def test_simple_protocol(self):
"""
Test a simple protocol with
preamble, sync and increasing sequence number (8 bit) and some constant data
:return:
"""
mb = MessageTypeBuilder("simple_seq_test")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.SEQUENCE_NUMBER, 8)
num_messages = 20
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"})
for i in range(num_messages):
pg.generate_message(data="0xcafe")
#self.save_protocol("simple_sequence_number", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
seq_engine = SequenceNumberEngine(ff.bitvectors, n_gram_length=8)
highscored_ranges = seq_engine.find()
self.assertEqual(len(highscored_ranges), 1)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertGreater(len(ff.message_types[0]), 0)
self.assertEqual(
ff.message_types[0].num_labels_with_type(
FieldType.Function.SEQUENCE_NUMBER), 1)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.SEQUENCE_NUMBER)
self.assertEqual(label.start, 24)
self.assertEqual(label.length, 8)
def test_16bit_seq_nr_with_zeros_in_first_part(self):
mb = MessageTypeBuilder("16bit_seq_first_byte_zero_test")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 8)
mb.add_label(FieldType.Function.SEQUENCE_NUMBER, 16)
num_messages = 10
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"},
sequence_number_increment=1)
for i in range(num_messages):
pg.generate_message(data="0xcafe" + "abc" * i)
#self.save_protocol("16bit_seq_first_byte_zero_test", pg)
bitvectors = FormatFinder.get_bitvectors_from_messages(
pg.protocol.messages, sync_ends=[24] * num_messages)
seq_engine = SequenceNumberEngine(bitvectors, n_gram_length=8)
highscored_ranges = seq_engine.find()
self.assertEqual(len(highscored_ranges), 1)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertGreater(len(ff.message_types[0]), 0)
self.assertEqual(
ff.message_types[0].num_labels_with_type(
FieldType.Function.SEQUENCE_NUMBER), 1)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.SEQUENCE_NUMBER)
# Not consider constants as part of SEQ Nr!
self.assertEqual(label.start, 40)
self.assertEqual(label.length, 8)
def test_simple_protocol(self):
"""
Test a simple protocol with
preamble, sync and length field (8 bit) and some random data
:return:
"""
mb = MessageTypeBuilder("simple_length_test")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 8)
num_messages_by_data_length = {8: 5, 16: 10, 32: 15}
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"})
random.seed(0)
for data_length, num_messages in num_messages_by_data_length.items():
for i in range(num_messages):
pg.generate_message(data="".join(
[random.choice(["0", "1"]) for _ in range(data_length)]))
#self.save_protocol("simple_length", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
length_engine = LengthEngine(ff.bitvectors)
highscored_ranges = length_engine.find(n_gram_length=8)
self.assertEqual(len(highscored_ranges), 3)
ff.perform_iteration()
self.assertEqual(len(ff.message_types), 1)
self.assertGreater(len(ff.message_types[0]), 0)
label = ff.message_types[0].get_first_label_with_type(
FieldType.Function.LENGTH)
self.assertEqual(label.start, 24)
self.assertEqual(label.length, 8)
def test_format_finding_rwe_zeroed_crc(self):
ff = FormatFinder(self.zero_crc_protocol, self.participants)
ff.perform_iteration()
def test_format_finding_without_participants(self):
for msg in self.zero_crc_protocol.messages:
msg.participant = None
ff = FormatFinder(self.zero_crc_protocol, [])
ff.perform_iteration()
def auto_assign_labels(self):
format_finder = FormatFinder(self)
# OPEN: Perform multiple iterations with varying priorities later
format_finder.perform_iteration()
def test_format_finding_rwe_zeroed_crc(self):
ff = FormatFinder(self.zero_crc_protocol, self.participants)
ff.perform_iteration()
def test_format_finding_without_participants(self):
for msg in self.zero_crc_protocol.messages:
msg.participant = None
ff = FormatFinder(self.zero_crc_protocol, [])
ff.perform_iteration()
def test_two_participants(self):
mb = MessageTypeBuilder("address_two_participants")
mb.add_label(FieldType.Function.PREAMBLE, 8)
mb.add_label(FieldType.Function.SYNC, 16)
mb.add_label(FieldType.Function.LENGTH, 8)
mb.add_label(FieldType.Function.SRC_ADDRESS, 16)
mb.add_label(FieldType.Function.DST_ADDRESS, 16)
num_messages = 50
pg = ProtocolGenerator([mb.message_type],
syncs_by_mt={mb.message_type: "0x9a9d"},
participants=[self.alice, self.bob])
for i in range(num_messages):
if i % 2 == 0:
source, destination = self.alice, self.bob
data_length = 8
else:
source, destination = self.bob, self.alice
data_length = 16
pg.generate_message(data=pg.decimal_to_bits(4 * i, data_length),
source=source,
destination=destination)
#self.save_protocol("address_two_participants", pg)
self.clear_message_types(pg.protocol.messages)
ff = FormatFinder(pg.protocol.messages)
address_engine = AddressEngine(ff.hexvectors, ff.participant_indices)
address_dict = address_engine.find_addresses()
self.assertEqual(len(address_dict), 2)
addresses_1 = list(
map(util.convert_numbers_to_hex_string, address_dict[0]))
addresses_2 = list(
map(util.convert_numbers_to_hex_string, address_dict[1]))
self.assertIn(self.alice.address_hex, addresses_1)
self.assertIn(self.alice.address_hex, addresses_2)
self.assertIn(self.bob.address_hex, addresses_1)
self.assertIn(self.bob.address_hex, addresses_2)
ff.known_participant_addresses.clear()
self.assertEqual(len(ff.known_participant_addresses), 0)
ff.perform_iteration()
self.assertEqual(len(ff.known_participant_addresses), 2)
self.assertIn(bytes([int(h, 16) for h in self.alice.address_hex]),
map(bytes, ff.known_participant_addresses.values()))
self.assertIn(bytes([int(h, 16) for h in self.bob.address_hex]),
map(bytes, ff.known_participant_addresses.values()))
self.assertEqual(len(ff.message_types), 1)
mt = ff.message_types[0]
dst_addr = mt.get_first_label_with_type(FieldType.Function.DST_ADDRESS)
self.assertIsNotNone(dst_addr)
self.assertEqual(dst_addr.start, 32)
self.assertEqual(dst_addr.length, 16)
src_addr = mt.get_first_label_with_type(FieldType.Function.SRC_ADDRESS)
self.assertIsNotNone(src_addr)
self.assertEqual(src_addr.start, 48)
self.assertEqual(src_addr.length, 16)
def auto_assign_labels(self):
format_finder = FormatFinder(self)
# OPEN: Perform multiple iterations with varying priorities later
format_finder.perform_iteration()