def setUp(self):
filename = os.path.join(tempfile.gettempdir(), "test.fuzz")
mod1 = Modulator("mod 1")
mod2 = Modulator("mod 2")
mod2.param_for_one = 42
decoders = [
Encoder(["NRZ"]),
Encoder(["NRZ-I", constants.DECODING_INVERT])
]
pac = ProtocolAnalyzerContainer([mod1, mod2])
pac.messages.append(
Message([True, False, False, True, "A"],
100,
decoder=decoders[0],
message_type=pac.default_message_type))
pac.messages.append(
Message([False, False, False, False, "A"],
200,
decoder=decoders[1],
message_type=pac.default_message_type))
pac.used_symbols.add(Symbol("A", 1, 1, 100))
pac.create_fuzzing_label(1, 10, 0)
pac.to_xml_file(filename)
def prepare_modulation_dialog(
self) -> (ModulatorDialogController, Message):
preselected_index = self.ui.cBoxModulations.currentIndex()
min_row, max_row, start, end = self.ui.tableMessages.selection_range()
if min_row > -1:
try:
selected_message = self.table_model.protocol.messages[min_row]
preselected_index = selected_message.modulator_indx
except IndexError:
selected_message = Message([True, False, True, False], 0, [],
MessageType("empty"))
else:
selected_message = Message([True, False, True, False], 0, [],
MessageType("empty"))
if len(self.table_model.protocol.messages) > 0:
selected_message.bit_len = self.table_model.protocol.messages[
0].bit_len
for m in self.modulators:
m.default_sample_rate = self.project_manager.device_conf[
"sample_rate"]
modulator_dialog = ModulatorDialogController(self.modulators,
parent=self.parent())
modulator_dialog.ui.treeViewSignals.setModel(self.tree_model)
modulator_dialog.ui.treeViewSignals.expandAll()
modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex(
preselected_index)
modulator_dialog.finished.connect(self.refresh_modulators)
modulator_dialog.finished.connect(self.refresh_pause_list)
return modulator_dialog, selected_message
def prepare_modulation_dialog(self) -> (ModulatorDialog, Message):
preselected_index = self.ui.cBoxModulations.currentIndex()
min_row, max_row, start, end = self.ui.tableMessages.selection_range()
if min_row > -1:
try:
selected_message = self.table_model.protocol.messages[min_row]
preselected_index = selected_message.modulator_index
except IndexError:
selected_message = Message(
[1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [],
MessageType("empty"))
else:
selected_message = Message(
[1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [],
MessageType("empty"))
if len(self.table_model.protocol.messages) > 0:
selected_message.samples_per_symbol = self.table_model.protocol.messages[
0].samples_per_symbol
for m in self.modulators:
m.default_sample_rate = self.project_manager.device_conf[
"sample_rate"]
modulator_dialog = ModulatorDialog(self.modulators,
tree_model=self.tree_model,
parent=self.parent())
modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex(
preselected_index)
modulator_dialog.finished.connect(self.refresh_modulators)
modulator_dialog.finished.connect(self.refresh_pause_list)
return modulator_dialog, selected_message
def redo(self):
message = copy.deepcopy(self.proto_analyzer.messages[self.msg_nr])
message1 = Message(plain_bits=message.plain_bits[:self.pos], pause=0,
rssi=0, decoder=message.decoder, message_type=message.message_type,
bit_len=message.bit_len)
message2 = Message(plain_bits=message.plain_bits[self.pos:], pause=message.pause,
rssi=0, decoder=message.decoder, message_type=message.message_type,
bit_len=message.bit_len)
self.proto_analyzer.messages[self.msg_nr] = message1
self.proto_analyzer.messages.insert(self.msg_nr + 1, message2)
def test_binary_format(self):
pa = ProtocolAnalyzer(None)
pa.messages.append(
Message([1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1], 0,
pa.default_message_type))
pa.messages.append(Message([1, 1, 1, 0, 1], 0,
pa.default_message_type))
filename = os.path.join(tempfile.gettempdir(), "test_proto.bin")
pa.to_binary(filename, use_decoded=True)
pa.from_binary(filename)
self.assertEqual(len(pa.messages), 3)
self.assertEqual(pa.plain_bits_str[2], "111000111001101111101000")
def test_default_crcs(self):
crc_label = ChecksumLabel(
"crc_label", 25, 120, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
crc_label, Message([0] * 150, 0, MessageType("test")), 0)
default_crc_polynomials = GenericCRC.DEFAULT_POLYNOMIALS
special_crcs = ChecksumWidgetController.SPECIAL_CRCS
self.assertEqual(
len(default_crc_polynomials) + len(special_crcs),
crc_widget_controller.ui.comboBoxCRCFunction.count())
for i, default_polynomial_name in enumerate(default_crc_polynomials):
self.assertEqual(
default_polynomial_name,
crc_widget_controller.ui.comboBoxCRCFunction.itemText(i))
for i, special_crc in enumerate(special_crcs):
self.assertEqual(
special_crc,
crc_widget_controller.ui.comboBoxCRCFunction.itemText(
i + len(default_crc_polynomials)))
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(1)
self.assertNotEqual(
crc_widget_controller.ui.comboBoxCRCFunction.currentText(),
"8_standard")
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentText(
"8_standard")
self.assertEqual(
crc_widget_controller.ui.comboBoxCRCFunction.currentText(),
"8_standard")
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
"d5")
def from_binary(self, filename: str):
aggregated = np.fromfile(filename, dtype=np.uint8)
unaggregated = [
int(b) for n in aggregated for b in "{0:08b}".format(n)
]
self.messages.append(
Message(unaggregated, 0, self.default_message_type))
def test_configure_crc_parameters(self):
crc_label = ChecksumLabel(
"crc_label", 25, 120, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
crc_label, Message([0] * 150, 0, MessageType("test")), 0)
crc = GenericCRC(
polynomial=list(GenericCRC.DEFAULT_POLYNOMIALS.keys())[0])
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
crc.polynomial_as_hex_str)
self.assertEqual(crc_widget_controller.ui.lineEditStartValue.text(),
util.bit2hex(crc.start_value))
self.assertEqual(crc_widget_controller.ui.lineEditFinalXOR.text(),
util.bit2hex(crc.final_xor))
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(2)
crc.polynomial = crc.choose_polynomial(2)
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
crc.polynomial_as_hex_str)
crc_widget_controller.ui.lineEditCRCPolynomial.setText("abcde")
crc_widget_controller.ui.lineEditCRCPolynomial.editingFinished.emit()
self.assertEqual(crc_label.checksum.polynomial,
array.array("B", [1]) + util.hex2bit("abcde"))
crc_widget_controller.ui.lineEditStartValue.setText("12345")
crc_widget_controller.ui.lineEditStartValue.editingFinished.emit()
self.assertEqual(util.bit2hex(crc_label.checksum.start_value), "12345")
crc_widget_controller.ui.lineEditFinalXOR.setText("cccaa")
crc_widget_controller.ui.lineEditFinalXOR.editingFinished.emit()
self.assertEqual(util.bit2hex(crc_label.checksum.final_xor), "cccaa")
def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
ppseq = signalFunctions.grab_pulse_lens(signal.qad, signal.qad_center,
signal.tolerance,
signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal.data[start:end]))
message = Message(bits,
pause,
message_type=self.default_message_type,
bit_len=bit_len,
rssi=rssi,
decoder=self.decoder,
bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
ppseq = signal_functions.grab_pulse_lens(signal.qad, signal.qad_center, signal.tolerance,
signal.modulation_type, signal.bit_len, signal.bits_per_symbol)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len, self.signal.bits_per_symbol,
pause_threshold=signal.pause_threshold)
if signal.message_length_divisor > 1 and signal.modulation_type == "ASK":
self.__ensure_message_length_multiple(bit_data, signal.bit_len, pauses, bit_sample_pos,
signal.message_length_divisor)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(signal.iq_array.subarray(start, end).magnitudes_normalized)
message = Message(bits, pause, message_type=self.default_message_type,
bit_len=bit_len, rssi=rssi, decoder=self.decoder, bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def redo(self):
message = self.proto_analyzer.messages[self.msg_nr]
message1 = Message(plain_bits=message.plain_bits[:self.pos],
pause=0,
rssi=message.rssi,
decoder=message.decoder,
message_type=message.message_type,
samples_per_symbol=message.samples_per_symbol)
message2 = Message(plain_bits=message.plain_bits[self.pos:],
pause=message.pause,
rssi=message.rssi,
decoder=message.decoder,
message_type=message.message_type,
samples_per_symbol=message.samples_per_symbol)
self.proto_analyzer.messages[self.msg_nr] = message1
self.proto_analyzer.messages.insert(self.msg_nr + 1, message2)
def fuzz(self, mode: FuzzMode, default_pause=None):
result = []
appd_result = result.append
added_message_indices = []
for i, msg in enumerate(self.messages):
labels = msg.active_fuzzing_labels
appd_result(msg)
if mode == FuzzMode.successive:
combinations = [[(l.start, l.end, fuzz_val)] for l in labels
for fuzz_val in l.fuzz_values[1:]]
elif mode == FuzzMode.concurrent:
num_values = numpy.max([len(l.fuzz_values)
for l in labels]) if labels else 0
f = lambda index, label: index if index < len(label.fuzz_values
) else 0
combinations = [[(l.start, l.end, l.fuzz_values[f(j, l)])
for l in labels]
for j in range(1, num_values)]
elif mode == FuzzMode.exhaustive:
pool = [[(l.start, l.end, fv) for fv in l.fuzz_values[1:]]
for l in labels]
combinations = itertools.product(*pool) if labels else []
else:
raise ValueError("Unknown fuzz mode")
self.qt_signals.fuzzing_started.emit(len(combinations))
message_type = copy.copy(msg.message_type)
for lbl in labels:
lbl = copy.copy(lbl)
lbl.fuzz_values = []
lbl.fuzz_created = True
message_type[message_type.index(lbl)] = lbl
for j, combination in enumerate(combinations):
cpy_bits = msg.plain_bits[:]
for start, end, fuz_val in combination:
cpy_bits[start:end] = array.array("B", map(int, fuz_val))
pause = default_pause if default_pause is not None else msg.pause
fuz_msg = Message(plain_bits=cpy_bits,
pause=pause,
rssi=msg.rssi,
message_type=message_type,
modulator_index=msg.modulator_index,
decoder=msg.decoder,
fuzz_created=True,
participant=msg.participant)
added_message_indices.append(i + j + 1)
appd_result(fuz_msg)
if j % 10000 == 0:
self.qt_signals.current_fuzzing_message_changed.emit(j)
self.qt_signals.fuzzing_finished.emit()
self.messages = result # type: list[Message]
return added_message_indices
def insert_protocol_analyzer(self, index: int, proto_analyzer: ProtocolAnalyzer):
for msg in reversed(proto_analyzer.messages):
self.messages.insert(index, Message(plain_bits=msg.decoded_bits, pause=msg.pause,
message_type=copy.copy(msg.message_type),
rssi=msg.rssi, modulator_indx=0, decoder=msg.decoder,
bit_len=msg.bit_len, participant=msg.participant))
if len(self.pauses) > 0:
self.fuzz_pause = self.pauses[0]
def __build_protocol(self):
result = ProtocolAnalyzer(signal=None)
for _ in range(self.NUM_MESSAGES):
b = Message([True] * self.BITS_PER_MESSAGE,
pause=1000,
message_type=result.default_message_type)
result.messages.append(b)
return result
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
signal = self.signal
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
signal._fulldata = np.concatenate(self.data_cache)
del self.data_cache[:]
signal._qad = None
bit_len = signal.bit_len
ppseq = grab_pulse_lens(signal.qad, signal.qad_center,
signal.tolerance, signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, self.rel_symbol_len)
i = 0
first_msg = True
for bits, pause in zip(bit_data, pauses):
if first_msg or self.messages[-1].pause > 8 * bit_len:
# Create new Message
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal._fulldata[start:end]))
message = Message(bits,
pause,
bit_len=bit_len,
rssi=rssi,
message_type=self.default_message_type)
self.messages.append(message)
first_msg = False
else:
# Append to last message
message = self.messages[-1]
nzeros = int(np.round(message.pause / bit_len))
message.plain_bits.extend([False] * nzeros)
message.plain_bits.extend(bits)
message.pause = pause
i += 1
def add_empty_row_behind(self, row_index: int, num_bits: int):
message = Message(plain_bits=[0]*num_bits,
pause=constants.SETTINGS.value("default_fuzzing_pause", 10**6, int),
message_type=self.protocol.default_message_type)
tmp_protocol = ProtocolAnalyzer(None)
tmp_protocol.messages = [message]
undo_action = InsertBitsAndPauses(self.protocol, row_index+1, tmp_protocol)
self.undo_stack.push(undo_action)
def test_crc_widget_in_protocol_label_dialog(self):
mt = MessageType("test")
mt.append(
ChecksumLabel("test_crc", 8, 16, 0,
FieldType("test_crc", FieldType.Function.CHECKSUM)))
self.dialog = ProtocolLabelController(0, Message([0] * 100, 0, mt), 0)
self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.count(), 1)
self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.tabText(0),
"test_crc")
def __build_protocol(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
result = ProtocolAnalyzer(signal=None)
for _ in range(self.NUM_MESSAGES):
b = Message([True] * self.BITS_PER_MESSAGE,
pause=1000,
message_type=result.default_message_type)
result.messages.append(b)
return result
def __get_continuous_send_dialog(self):
messages = [Message([True]*100, 1000, self.form.compare_frame_controller.active_message_type) for _ in range(10)]
modulators = [Modulator("Test")]
continuous_send_dialog = ContinuousSendDialogController(self.form.project_manager, messages, modulators,
self.form.generator_tab_controller.total_modulated_samples,
parent=self.form, testing_mode=True)
if self.SHOW:
continuous_send_dialog.show()
return continuous_send_dialog
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
self.signal._fulldata = np.concatenate(self.data_cache)
self.data_cache.clear()
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance,
self.signal.modulation_type,
self.signal.bit_len)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, write_bit_sample_pos=False)
i = 0
first_msg = True
for bits, pause in zip(bit_data, pauses):
if first_msg or self.messages[-1].pause > 8 * bit_len:
message = Message(bits,
pause,
bit_len=bit_len,
message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
first_msg = False
else:
# Append to last message
message = self.messages[-1]
nzeros = int(np.round(message.pause / bit_len))
message.plain_bits.extend([False] * nzeros)
message.plain_bits.extend(bits)
message.pause = pause
i += 1
def test_load_profile(self):
filename = os.path.join(tempfile.gettempdir(), "test.fuzz.xml")
mod1 = Modulator("mod 1")
mod2 = Modulator("mod 2")
mod2.param_for_one = 42
decoders = [
Encoding(["NRZ"]),
Encoding(["NRZ-I", constants.DECODING_INVERT])
]
pac = ProtocolAnalyzerContainer()
pac.messages.append(
Message([True, False, False, True],
100,
decoder=decoders[0],
message_type=pac.default_message_type))
pac.messages.append(
Message([False, False, False, False],
200,
decoder=decoders[1],
message_type=pac.default_message_type))
pac.create_fuzzing_label(1, 10, 0)
assert isinstance(self.form, MainController)
pac.to_xml_file(filename,
decoders=decoders,
participants=self.form.project_manager.participants)
self.wait_before_new_file()
self.form.add_files(
[os.path.join(tempfile.gettempdir(), "test.fuzz.xml")])
self.assertEqual(self.form.ui.tabWidget.currentWidget(),
self.form.ui.tab_generator)
pac = self.form.generator_tab_controller.table_model.protocol
self.assertEqual(len(pac.messages), 2)
self.assertEqual(pac.messages[1][0], False)
self.assertEqual(len(pac.protocol_labels), 1)
def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
try:
ppseq = signal_functions.grab_pulse_lens(signal.qad,
signal.qad_center,
signal.tolerance,
signal.modulation_type,
signal.bit_len)
except TypeError:
# Remove this check in version 1.7
print(
"Extension method has changed! To fix this, first move to URHs base directory "
"then recompile the extensions using the following command:")
print("python3 src/urh/cythonext/build.py")
print("and finally restart the application")
sys.exit(1)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, pause_threshold=signal.pause_threshold)
if signal.message_length_divisor > 1 and signal.modulation_type_str == "ASK":
self.__ensure_message_length_multiple(
bit_data, signal.bit_len, pauses, bit_sample_pos,
signal.message_length_divisor)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal.data[start:end]))
message = Message(bits,
pause,
message_type=self.default_message_type,
bit_len=bit_len,
rssi=rssi,
decoder=self.decoder,
bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def generate_message_from_template(self, template_msg: SimulatorMessage):
new_message = Message(template_msg.plain_bits,
pause=template_msg.pause,
rssi=0,
message_type=template_msg.message_type,
decoder=template_msg.decoder)
for lbl in template_msg.children: # type: SimulatorProtocolLabel
if lbl.value_type_index == 2:
# formula
valid, _, node = self.expression_parser.validate_expression(
lbl.formula)
assert valid
result = self.expression_parser.evaluate_node(node)
elif lbl.value_type_index == 3:
transcript = self.transcript.get_for_participant(
template_msg.source if template_msg.source.
simulate else template_msg.destination)
if template_msg.destination.simulate:
direction = "->" if template_msg.source.simulate else "<-"
transcript += "\n" + direction + new_message.plain_bits_str + "\n"
cmd = self.__fill_counter_values(lbl.external_program)
result = util.run_command(cmd, transcript, use_stdin=True)
if len(result) != lbl.end - lbl.start:
log_msg = "Result value of external program {}: {} ({}) does not match label length {}"
logger.error(
log_msg.format(cmd, result, len(result),
lbl.end - lbl.start))
continue
try:
new_message[lbl.start:lbl.end] = array.array(
"B", (map(bool, map(int, result))))
except Exception as e:
log_msg = "Could not assign {} to range because {}".format(
result, e)
logger.error(log_msg)
continue
elif lbl.value_type_index == 4:
# random value
result = numpy.random.randint(lbl.random_min,
lbl.random_max + 1)
else:
continue
self.set_label_value(new_message, lbl, result)
return new_message
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if len(data) == 0:
return
rssi_squared = np.mean(data.real**2 + data.imag**2)
is_above_noise = rssi_squared > self.signal.noise_threshold**2
if self.adaptive_noise and not is_above_noise:
self.signal.noise_threshold = 0.9 * self.signal.noise_threshold + 0.1 * np.max(
np.abs(data))
if is_above_noise:
self.data_cache.append(data)
self.pause_length = 0
return
else:
self.pause_length += len(data)
if self.pause_length < 10 * self.signal.bit_len:
self.data_cache.append(data)
return
if len(self.data_cache) == 0:
return
# clear cache and start a new message
self.signal._fulldata = np.concatenate(self.data_cache)
self.data_cache.clear()
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance,
self.signal.modulation_type,
self.signal.bit_len)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, write_bit_sample_pos=False)
for bits, pause in zip(bit_data, pauses):
message = Message(bits,
pause,
bit_len=bit_len,
message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
self.message_sniffed.emit(len(self.messages) - 1)
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if len(data) == 0:
return
power_spectrum = data.real ** 2 + data.imag ** 2
is_above_noise = np.sqrt(np.mean(power_spectrum)) > self.signal.noise_threshold
if self.adaptive_noise and not is_above_noise:
self.signal.noise_threshold = 0.9 * self.signal.noise_threshold + 0.1 * np.sqrt(np.max(power_spectrum))
if is_above_noise:
self.__add_to_buffer(data)
self.pause_length = 0
if not self.__buffer_is_full():
return
else:
self.pause_length += len(data)
if self.pause_length < 10 * self.signal.bit_len:
self.__add_to_buffer(data)
if not self.__buffer_is_full():
return
if self.__current_buffer_index == 0:
return
# clear cache and start a new message
self.signal._fulldata = self.__buffer[0:self.__current_buffer_index]
self.__clear_buffer()
self.signal._qad = None
bit_len = self.signal.bit_len
if self.automatic_center:
self.signal.qad_center = AutoInterpretation.detect_center(self.signal.qad, max_size=150*self.signal.bit_len)
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance, self.signal.modulation_type, self.signal.bit_len)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len, write_bit_sample_pos=False)
for bits, pause in zip(bit_data, pauses):
message = Message(bits, pause, bit_len=bit_len, message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
self.message_sniffed.emit(len(self.messages) - 1)
def fuzz(self, mode: FuzzMode, default_pause=None):
result = []
appd_result = result.append
for i, msg in enumerate(self.messages):
labels = msg.active_fuzzing_labels
appd_result(msg)
if mode == FuzzMode.successive:
combinations = [[(l.start, l.end, fuzz_val)] for l in labels
for fuzz_val in l.fuzz_values[1:]]
elif mode == FuzzMode.concurrent:
nval = numpy.max([len(l.fuzz_values)
for l in labels]) if labels else 0
f = lambda index, label: index if index < len(label.fuzz_values
) else 0
combinations = [[(l.start, l.end, l.fuzz_values[f(j, l)])
for l in labels] for j in range(1, nval)]
elif mode == FuzzMode.exhaustive:
pool = [[(l.start, l.end, fv) for fv in l.fuzz_values[1:]]
for l in labels]
combinations = itertools.product(*pool) if labels else []
else:
raise ValueError("Unknown fuzz mode")
for combination in combinations:
cpy_bits = msg.plain_bits[:]
for start, end, fuz_val in combination:
cpy_bits[start:end] = [
True if bit == "1" else False for bit in fuz_val
]
pause = default_pause if default_pause is not None else msg.pause
fuz_msg = Message(
plain_bits=cpy_bits,
pause=pause,
rssi=msg.rssi,
message_type=msg.message_type.copy_for_fuzzing(),
modulator_indx=msg.modulator_indx,
decoder=msg.decoder,
fuzz_created=True)
appd_result(fuz_msg)
self.messages = result
""":type: list of Message """
def test_enocean_checksum(self):
checksum_label = ChecksumLabel(
"checksum_label", 50, 100, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
checksum_label, Message([0] * 100, 0, MessageType("test")), 0)
crc_widget_controller.ui.comboBoxCategory.setCurrentIndex(1)
self.assertEqual(
crc_widget_controller.ui.stackedWidget.currentWidget(),
crc_widget_controller.ui.page_wsp)
self.assertTrue(
crc_widget_controller.ui.radioButtonWSPAuto.isChecked())
crc_widget_controller.ui.radioButtonWSPChecksum8.click()
self.assertEqual(checksum_label.checksum.mode,
WSPChecksum.ChecksumMode.checksum8)
def generate_de_bruijn(self, row_index: int, start: int, end: int):
if start < 0 or end < 0:
return
f = 1 if self.proto_view == 0 else 4 if self.proto_view == 1 else 8
start, end = f * start, f * end
de_bruijn_seq = util.de_bruijn(end-start)
tmp_protocol = ProtocolAnalyzer(None)
tmp_protocol.messages = []
LINE_BREAK_AFTER = 5000 * f
for i in range(0, len(de_bruijn_seq), LINE_BREAK_AFTER):
message = Message(plain_bits=de_bruijn_seq[i:i+LINE_BREAK_AFTER],
pause=0,
message_type=self.protocol.default_message_type)
tmp_protocol.messages.append(message)
undo_action = InsertBitsAndPauses(self.protocol, row_index+1, tmp_protocol)
self.undo_stack.push(undo_action)
def insert_protocol_analyzer(self, index: int,
proto_analyzer: ProtocolAnalyzer):
messages = [
Message(plain_bits=copy.copy(msg.decoded_bits),
pause=msg.pause,
message_type=copy.deepcopy(msg.message_type),
rssi=msg.rssi,
modulator_indx=0,
decoder=msg.decoder,
bit_len=msg.bit_len,
participant=msg.participant)
for msg in proto_analyzer.messages if msg
]
self.messages[index:0] = messages
self.used_symbols |= proto_analyzer.used_symbols
if len(self.pauses) > 0:
self.fuzz_pause = self.pauses[0]
def test_configure_crc_ranges(self):
checksum_label = ChecksumLabel(
"checksum_label", 50, 100, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
checksum_label, Message([0] * 100, 0, MessageType("test")), 0)
model = crc_widget_controller.data_range_table_model
self.assertEqual(model.data(model.index(0, 0)), 1)
self.assertEqual(model.data(model.index(0, 1)), 50)
self.assertEqual(model.rowCount(), 1)
crc_widget_controller.ui.btnAddRange.click()
self.assertEqual(model.rowCount(), 2)
crc_widget_controller.ui.btnAddRange.click()
self.assertEqual(model.rowCount(), 3)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 2)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 1)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 1)