def __demodulate(self, connection: socket.socket):
connection.settimeout(0.1)
time.sleep(self.TIMEOUT)
total_data = []
while True:
try:
data = connection.recv(65536)
if data:
total_data.append(data)
else:
break
except socket.timeout:
break
if len(total_data) == 0:
logger.error("Did not receive any data from socket.")
arr = np.array(np.frombuffer(b"".join(total_data), dtype=np.complex64))
signal = Signal("", "")
signal._fulldata = arr
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
return pa.plain_bits_str
def set_signal(self):
indx = self.ui.combobox_signals.currentIndex()
if indx != 0:
self.ui.inpt.setReadOnly(True)
else:
self.ui.inpt.setReadOnly(False)
self.ui.inpt.setText("10010110")
self.decoder_update()
return
signal = self.signals[indx - 1]
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.ui.inpt.setText("".join(pa.decoded_proto_bits_str))
tmp_scene = QGraphicsScene()
tmp_scene.addText(self.tr("Loading Signal..."))
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
self.ui.graphicsView_signal.setScene(tmp_scene)
if signal is not None:
last_message = pa.messages[-1]
lookup = {i: msg.bit_sample_pos for i, msg in enumerate(pa.messages)}
plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages - 1][len(last_message) - 1]]
self.ui.graphicsView_signal.plot_data(plot_data)
self.ui.graphicsView_signal.centerOn(0, 0)
QApplication.instance().restoreOverrideCursor()
def test_cli_modulate_messages(self):
modulator = Modulator("test")
modulator.sample_rate = 2e3
modulator.samples_per_bit = 100
modulator.modulation_type_str = "ASK"
modulator.param_for_zero = 0
modulator.param_for_one = 100
bits = "1010111100001"
self.assertIsNone(urh_cli.modulate_messages([], modulator))
message = Message.from_plain_bits_str(bits, pause=1000)
modulated = urh_cli.modulate_messages([message], modulator)
# Demodulate for testing
s = Signal("", "", modulation="ASK", sample_rate=2e6)
s.bit_len = 100
s.noise_threshold = 0
s._fulldata = modulated
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(len(pa.messages), 1)
self.assertEqual(pa.messages[0].plain_bits_str, bits)
def set_signal(self):
indx = self.ui.combobox_signals.currentIndex()
if indx != 0:
self.ui.inpt.setReadOnly(True)
else:
self.ui.inpt.setReadOnly(False)
self.ui.inpt.setText("10010110")
self.decoder_update()
return
self.setCursor(Qt.WaitCursor)
signal = self.signals[indx - 1]
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.ui.inpt.setText("".join(pa.plain_bits_str))
self.ui.inpt.setCursorPosition(0)
if signal is not None and pa.messages:
last_message = pa.messages[-1]
lookup = {i: msg.bit_sample_pos for i, msg in enumerate(pa.messages)}
plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages - 1][len(last_message) - 1]]
self.ui.graphicsView_signal.plot_data(plot_data)
self.ui.graphicsView_signal.centerOn(0, 0)
self.unsetCursor()
def demodulate(signal_data,
mod_type: str,
bit_length,
center,
noise,
tolerance,
decoding=None,
pause_threshold=8):
signal = Signal("", "")
if isinstance(signal_data, IQArray):
signal.iq_array = signal_data
else:
if signal_data.dtype == np.complex64:
signal.iq_array = IQArray(signal_data.view(np.float32))
else:
signal.iq_array = IQArray(signal_data)
signal.modulation_type = mod_type
signal.bit_len = bit_length
signal.qad_center = center
signal.noise_threshold = noise
signal.pause_threshold = pause_threshold
if tolerance is not None:
signal.tolerance = tolerance
pa = ProtocolAnalyzer(signal)
if decoding is not None:
pa.decoder = decoding
pa.get_protocol_from_signal()
return pa.decoded_hex_str
def test_cli_modulate_messages(self):
modulator = Modulator("test")
modulator.sample_rate = 2e3
modulator.samples_per_bit = 100
modulator.modulation_type_str = "ASK"
modulator.param_for_zero = 0
modulator.param_for_one = 100
bits = "1010111100001"
self.assertIsNone(urh_cli.modulate_messages([], modulator))
message = Message.from_plain_bits_str(bits, pause=1000)
modulated = urh_cli.modulate_messages([message], modulator)
# Demodulate for testing
s = Signal("", "", modulation="ASK", sample_rate=2e6)
s.bit_len = 100
s.noise_threshold = 0
s.iq_array = modulated
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(len(pa.messages), 1)
self.assertEqual(pa.messages[0].plain_bits_str, bits)
def test_protocol_with_acks_and_checksum(self):
proto_file = get_path_for_data_file("ack_frames_with_crc.proto.xml")
protocol = ProtocolAnalyzer(signal=None, filename=proto_file)
protocol.from_xml_file(filename=proto_file, read_bits=True)
self.clear_message_types(protocol.messages)
ff = FormatFinder(protocol.messages)
ff.known_participant_addresses.clear()
ff.run()
self.assertEqual(
util.convert_numbers_to_hex_string(
ff.known_participant_addresses[0]), "1337")
self.assertEqual(
util.convert_numbers_to_hex_string(
ff.known_participant_addresses[1]), "4711")
for mt in ff.message_types:
preamble = mt.get_first_label_with_type(
FieldType.Function.PREAMBLE)
self.assertEqual(preamble.start, 0)
self.assertEqual(preamble.length, 16)
sync = mt.get_first_label_with_type(FieldType.Function.SYNC)
self.assertEqual(sync.start, 16)
self.assertEqual(sync.length, 16)
length = mt.get_first_label_with_type(FieldType.Function.LENGTH)
self.assertEqual(length.start, 32)
self.assertEqual(length.length, 8)
def __init__(self, bit_len: int, center: float, noise: float,
tolerance: int, modulation_type: int, device: str,
backend_handler: BackendHandler):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler,
device,
Mode.receive,
is_ringbuffer=False,
raw_mode=False)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def __init__(self, bit_len: int, center: float, noise: float, tolerance:
int, modulation_type: int, sample_rate: float, freq: float, gain: int,
bandwidth: float, device: str, usrp_ip="192.168.10.2"):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = BackendHandler()
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive, bandwidth, freq, gain, sample_rate, device_ip=usrp_ip, is_ringbuffer=True)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.rcv_timer = QTimer()
self.rcv_timer.setInterval(1000)
self.rcv_timer.timeout.connect(self.on_rcv_timer_timeout)
self.rel_symbol_len = self._read_symbol_len()
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def set_signal(self):
indx = self.ui.combobox_signals.currentIndex()
if indx != 0:
self.ui.inpt.setReadOnly(True)
else:
self.ui.inpt.setReadOnly(False)
self.ui.inpt.setText("10010110")
self.decoder_update()
return
signal = self.signals[indx - 1]
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.ui.inpt.setText("".join(pa.decoded_proto_bits_str))
tmp_scene = QGraphicsScene()
tmp_scene.addText(self.tr("Loading Signal..."))
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ui.graphicsView_signal.setScene(tmp_scene)
QApplication.processEvents()
if signal is not None:
last_message = pa.messages[-1]
lookup = {
i: msg.bit_sample_pos
for i, msg in enumerate(pa.messages)
}
plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages -
1][len(last_message) -
1]]
self.ui.graphicsView_signal.plot_data(plot_data)
self.ui.graphicsView_signal.centerOn(0, 0)
QApplication.restoreOverrideCursor()
def test_protocol_sniffer(self):
samples_per_symbol = 100
center = 0.0942
noise = 0.1
tolerance = 2
modulation_type = "FSK"
sample_rate = 1e6
device_name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
sniffer = ProtocolSniffer(samples_per_symbol=samples_per_symbol, center=center, center_spacing=0.1,
noise=noise, tolerance=tolerance,
modulation_type=modulation_type, bits_per_symbol=1,
device=device_name, backend_handler=BackendHandler(),
network_raw_mode=True)
port = self.get_free_port()
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
self.network_sdr_plugin_sender.client_port = port
sniffer.sniff()
QTest.qWait(10)
data = ["101010", "000111", "1111000"]
pause = 10 * samples_per_symbol
modulator = Modulator("test")
modulator.samples_per_symbol = samples_per_symbol
modulator.sample_rate = sample_rate
modulator.modulation_type = modulation_type
modulator.parameters[1] = 20e3
modulator.parameters[0] = 10e3
packages = []
for d in data:
packages.append(modulator.modulate(list(map(int, d)), pause))
# verify modulation was correct
pa = ProtocolAnalyzer(None)
signal = Signal("", "", sample_rate=sample_rate)
signal.iq_array = IQArray.concatenate(packages)
signal.modulation_type = modulation_type
signal.samples_per_symbol = samples_per_symbol
signal.tolerance = tolerance
signal.noise_threshold = noise
signal.center = center
pa.signal = signal
pa.get_protocol_from_signal()
self.assertEqual(pa.plain_bits_str, data)
# send data
send_data = IQArray.concatenate(packages)
self.network_sdr_plugin_sender.send_raw_data(send_data, 1)
time.sleep(1)
# Send enough pauses to end sniffing
self.network_sdr_plugin_sender.send_raw_data(IQArray(None, np.float32, 10 * 2 * samples_per_symbol), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
def __demodulate(self, connection: socket.socket):
connection.settimeout(self.TIMEOUT)
time.sleep(self.TIMEOUT)
total_data = []
while True:
try:
data = connection.recv(65536)
if data:
total_data.append(data)
else:
break
except socket.timeout:
break
if len(total_data) == 0:
logger.error("Did not receive any data from socket.")
arr = IQArray(
np.array(np.frombuffer(b"".join(total_data), dtype=np.complex64)))
signal = Signal("", "")
signal.iq_array = arr
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
return pa.plain_bits_str
def setUp(self):
self.field_types = FieldType.default_field_types()
self.preamble_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.PREAMBLE)
self.sync_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.SYNC)
self.length_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.LENGTH)
self.sequence_number_field_type = self.__field_type_with_function(self.field_types,
FieldType.Function.SEQUENCE_NUMBER)
self.dst_address_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.DST_ADDRESS)
self.src_address_field_type = self.__field_type_with_function(self.field_types, FieldType.Function.SRC_ADDRESS)
self.protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("awre_consistent_addresses.txt")) as f:
for line in f:
self.protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.protocol.messages[-1].message_type = self.protocol.default_message_type
# Assign participants
alice = Participant("Alice", "A")
bob = Participant("Bob", "B")
alice_indices = {1, 2, 5, 6, 9, 10, 13, 14, 17, 18, 20, 22, 23, 26, 27, 30, 31, 34, 35, 38, 39, 41}
for i, message in enumerate(self.protocol.messages):
message.participant = alice if i in alice_indices else bob
self.participants = [alice, bob]
self.zero_crc_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("awre_zeroed_crc.txt")) as f:
for line in f:
self.zero_crc_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.zero_crc_protocol.messages[-1].message_type = self.protocol.default_message_type
for i, message in enumerate(self.zero_crc_protocol.messages):
message.participant = alice if i in alice_indices else bob
def __init__(self, bit_len: int, center: float, noise: float, tolerance: int,
modulation_type: int, device: str, backend_handler: BackendHandler):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive,
resume_on_full_receive_buffer=True, raw_mode=False)
self.rcv_device.index_changed.connect(self.on_rcv_thread_index_changed)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.data_cache = []
self.conseq_non_data = 0
self.reading_data = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def __init__(self, bit_len: int, center: float, noise: float, tolerance: int,
modulation_type: int, device: str, backend_handler: BackendHandler, network_raw_mode=False):
signal = Signal("", "LiveSignal")
signal.bit_len = bit_len
signal.qad_center = center
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.network_raw_mode = network_raw_mode
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler, device, Mode.receive,
resume_on_full_receive_buffer=True, raw_mode=network_raw_mode)
self.sniff_thread = Thread(target=self.check_for_data, daemon=True)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.__buffer = np.zeros(int(self.BUFFER_SIZE_MB * 1000 * 1000 / 8), dtype=np.complex64)
self.__current_buffer_index = 0
self.reading_data = False
self.adaptive_noise = False
self.automatic_center = False
self.pause_length = 0
self.is_running = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def set_signal(self):
indx = self.ui.combobox_signals.currentIndex()
if indx != 0:
self.ui.inpt.setReadOnly(True)
else:
self.ui.inpt.setReadOnly(False)
self.ui.inpt.setText("10010110")
self.decoder_update()
return
self.setCursor(Qt.WaitCursor)
signal = self.signals[indx - 1]
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.ui.inpt.setText("".join(pa.plain_bits_str))
self.ui.inpt.setCursorPosition(0)
if signal is not None and pa.messages:
last_message = pa.messages[-1]
lookup = {
i: msg.bit_sample_pos
for i, msg in enumerate(pa.messages)
}
plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages -
1][len(last_message) -
1]]
self.ui.graphicsView_signal.plot_data(plot_data)
self.ui.graphicsView_signal.centerOn(0, 0)
self.unsetCursor()
def test_protocol_sniffer(self):
bit_len = 100
center = 0.0942
noise = 0.1
tolerance = 2
modulation_type = 1
sample_rate = 1e6
device_name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
sniffer = ProtocolSniffer(bit_len=bit_len, center=center, noise=noise, tolerance=tolerance,
modulation_type=modulation_type, device=device_name, backend_handler=BackendHandler(),
network_raw_mode=True)
port = self.get_free_port()
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
self.network_sdr_plugin_sender.client_port = port
sniffer.sniff()
QTest.qWait(10)
data = ["101010", "000111", "1111000"]
pause = 10 * bit_len
modulator = Modulator("test")
modulator.samples_per_bit = bit_len
modulator.sample_rate = sample_rate
modulator.modulation_type = modulation_type
modulator.param_for_one = 20e3
modulator.param_for_zero = 10e3
packages = []
for d in data:
packages.append(modulator.modulate(list(map(int, d)), pause))
# verify modulation was correct
pa = ProtocolAnalyzer(None)
signal = Signal("", "", sample_rate=sample_rate)
signal._fulldata = np.concatenate(packages)
signal.modulation_type = modulation_type
signal.bit_len = bit_len
signal.tolerance = tolerance
signal.noise_threshold = noise
signal.qad_center = center
pa.signal = signal
pa.get_protocol_from_signal()
self.assertEqual(pa.plain_bits_str, data)
# send data
send_data = np.concatenate(packages)
self.network_sdr_plugin_sender.send_raw_data(send_data, 1)
time.sleep(1)
# Send enough pauses to end sniffing
self.network_sdr_plugin_sender.send_raw_data(np.zeros(10 * bit_len, dtype=np.complex64), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
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 __init__(self, project_manager, parent=None):
super().__init__(None, parent)
self.protocol = ProtocolAnalyzer(None)
self.project_manager = project_manager
self.decode = False
self.is_writeable = True
self.label_mask = defaultdict(lambda: False)
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_two_assign_participants_by_rssi(self):
rssis = [[
0.65389872, 0.13733707, 0.1226876, 0.73320961, 0.64940965,
0.12463234, 0.12296994, 0.68053716, 0.66020358, 0.12428901,
0.12312815, 0.69160986, 0.65582329, 0.12536003, 0.12587067,
0.66315573, 0.66313261, 0.12816505, 0.13491708, 0.66950738,
0.14047238
],
[
0.26651502, 0.2073856, 0.13547869, 0.25948182, 0.28204739,
0.13716124, 0.13526952, 0.24828221, 0.25431305,
0.13681877, 0.13650328, 0.28083691, 0.25550124,
0.13498682, 0.13611424, 0.2629154, 0.26388499, 0.13780586,
0.13561584, 0.27228078, 0.1356563
]]
proto1 = ProtocolAnalyzer(None)
proto2 = ProtocolAnalyzer(None)
for i in range(0, len(rssis[0])):
message = copy.deepcopy(self.protocol.messages[i])
message.participant = None
proto1.messages.append(message)
proto1.messages[i].rssi = rssis[0][i]
self.assertEqual(len(proto1.messages), 21)
for i in range(0, len(rssis[1])):
message = copy.deepcopy(self.protocol.messages[21 + i])
message.participant = None
proto2.messages.append(message)
proto2.messages[i].rssi = rssis[1][i]
self.assertEqual(len(proto2.messages), 21)
alice = Participant(name="Alice", shortname="A")
alice.relative_rssi = 1
bob = Participant(name="Bob", shortname="B")
bob.relative_rssi = 0
excpected_partis = [[
alice, bob, bob, alice, alice, bob, bob, alice, alice, bob, bob,
alice, alice, bob, bob, alice, alice, bob, bob, alice, bob
],
[
alice, bob, bob, alice, alice, bob, bob, alice,
alice, bob, bob, alice, alice, bob, bob, alice,
alice, bob, bob, alice, bob
]]
AutoAssigner.auto_assign_participants(proto1.messages, [alice, bob])
for i, message in enumerate(proto1.messages):
self.assertEqual(message.participant, excpected_partis[0][i])
AutoAssigner.auto_assign_participants(proto2.messages, [alice, bob])
for i, message in enumerate(proto2.messages):
self.assertEqual(message.participant, excpected_partis[1][i])
def test_ask(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = 0
signal.bit_len = 295
signal.qad_center = -0.1667
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011001001011011011011011011011011001000000"))
def test_fsk(self):
signal = Signal(get_path_for_data_file("fsk.complex"), "FSK-Test")
signal.modulation_type = 1
signal.bit_len = 100
signal.qad_center = 0
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0],
"101010101010101010101010101010101100011000100110110001100010011011110100110111000001110110011000111011101111011110100100001001111001100110011100110100100011100111010011111100011")
def add_plain_bits_from_txt(self, filename: str):
protocol = ProtocolAnalyzer(None)
protocol.filename = filename
with open(filename) as f:
for line in f:
protocol.messages.append(Message.from_plain_bits_str(line.strip()))
self.compare_frame_controller.add_protocol(protocol)
self.compare_frame_controller.refresh()
self.__add_empty_frame_for_filename(protocol, filename)
def add_plain_bits_from_txt(self, filename: str):
protocol = ProtocolAnalyzer(None)
protocol.filename = filename
with open(filename) as f:
for line in f:
protocol.messages.append(Message.from_plain_bits_str(line.strip()))
self.compare_frame_controller.add_protocol(protocol)
self.compare_frame_controller.refresh()
self.__add_empty_frame_for_filename(protocol, filename)
def test_get_bit_sample_pos(self):
signal = Signal(get_path_for_data_file("ASK_mod.complex"), "Bit sample pos test")
signal.modulation_type = 0
signal.bit_len = 100
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_messages, 1)
for i, pos in enumerate(proto_analyzer.messages[0].bit_sample_pos):
self.assertLess(pos, signal.num_samples, msg = i)
def test_fsk(self):
signal = Signal(get_path_for_data_file("fsk.complex"), "FSK-Test")
signal.modulation_type = "FSK"
signal.samples_per_symbol = 100
signal.center = 0
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0],
"101010101010101010101010101010101100011000100110110001100010011011110100110111000001110110011000111011101111011110100100001001111001100110011100110100100011100111010011111100011")
def test_ask(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = 0
signal.bit_len = 295
signal.qad_center = -0.1667
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011001001011011011011011011011011001000000"))
def test_ask(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = "ASK"
signal.samples_per_symbol = 295
signal.center = 0.0219
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011001001011011011011011011011011001000000"))
def test_psk(self):
signal = Signal(get_path_for_data_file("psk_gen_noisy.complex"), "PSK-Test")
signal.modulation_type = 2
signal.bit_len = 300
signal.qad_center = 0.0281
signal.noise_threshold = 0
signal.tolerance = 10
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0], "101100")
def test_get_bit_sample_pos(self):
signal = Signal("./data/ASK_mod.complex", "Bit sample pos test")
QTest.qWait(10)
signal.modulation_type = 0
signal.bit_len = 100
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_blocks, 1)
for i, pos in enumerate(proto_analyzer.bit_sample_pos[0]):
self.assertLess(pos, signal.num_samples, msg = i)
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_psk(self):
signal = Signal(get_path_for_data_file("psk_gen_noisy.complex"), "PSK-Test")
signal.modulation_type = "PSK"
signal.samples_per_symbol = 300
signal.center = 0
signal.noise_threshold = 0
signal.tolerance = 10
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertTrue(proto_analyzer.plain_bits_str[0].startswith("1011"), msg=proto_analyzer.plain_bits_str[0])
def test_psk(self):
signal = Signal(get_path_for_data_file("psk_gen_noisy.complex"), "PSK-Test")
signal.modulation_type = 2
signal.bit_len = 300
signal.qad_center = 0.0281
signal.noise_threshold = 0
signal.tolerance = 10
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0], "101100")
def test_get_bit_sample_pos(self):
signal = Signal(get_path_for_data_file("ASK_mod.complex"),
"Bit sample pos test")
signal.modulation_type = "ASK"
signal.samples_per_symbol = 100
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_messages, 1)
for i, pos in enumerate(proto_analyzer.messages[0].bit_sample_pos):
self.assertLess(pos, signal.num_samples, msg=i)
def __init__(self,
message_types: list,
participants: list = None,
preambles_by_mt=None,
syncs_by_mt=None,
little_endian=False,
length_in_bytes=True,
sequence_numbers=None,
sequence_number_increment=1,
message_type_codes=None):
"""
:param message_types:
:param participants:
:param preambles_by_mt:
:param syncs_by_mt:
:param byte_order:
:param length_in_bytes: If false length will be given in bit
"""
self.participants = participants if participants is not None else []
self.protocol = ProtocolAnalyzer(None)
self.protocol.message_types = message_types
self.length_in_bytes = length_in_bytes
self.little_endian = little_endian
preambles_by_mt = dict(
) if preambles_by_mt is None else preambles_by_mt
self.preambles_by_message_type = defaultdict(
lambda: self.DEFAULT_PREAMBLE)
for mt, preamble in preambles_by_mt.items():
self.preambles_by_message_type[mt] = self.to_bits(preamble)
syncs_by_mt = dict() if syncs_by_mt is None else syncs_by_mt
self.syncs_by_message_type = defaultdict(lambda: self.DEFAULT_SYNC)
for mt, sync in syncs_by_mt.items():
self.syncs_by_message_type[mt] = self.to_bits(sync)
sequence_numbers = dict(
) if sequence_numbers is None else sequence_numbers
self.sequence_numbers = defaultdict(lambda: 0)
self.sequence_number_increment = sequence_number_increment
for mt, seq in sequence_numbers.items():
self.sequence_numbers[mt] = seq
if message_type_codes is None:
message_type_codes = dict()
for i, mt in enumerate(self.message_types):
message_type_codes[mt] = i
self.message_type_codes = message_type_codes
def test_carrier_auto_detect(self):
signal = Signal(get_path_for_data_file("wsp.complex"), "test")
signal.modulation_type = "ASK"
signal.noise_threshold = 0.035
signal.center = 0.0245
signal.samples_per_symbol = 25
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
start, num_samples = pa.get_samplepos_of_bitseq(0, 0, 0, 999999, include_pause=False)
print("-----------")
print(signal.estimate_frequency(start, end=start+num_samples, sample_rate=2e6))
def test_fabema_get_proto(self):
signal = Signal("../../noack/USRP/Fabema/Testdata/trafficlight_fhside_full.complex", "PerfTest",
modulation="ASK")
signal.noise_threshold = 0.1
signal.qad_center = 0.009
signal.bit_len = 16
proto_analyzer = ProtocolAnalyzer(signal)
t = time.time()
proto_analyzer.get_protocol_from_signal()
dur = time.time() - t
print(self.prefix + "Get Protocol: {0:.2f}s".format(dur))
self.assertLess(dur, 2.85)
def test_carrier_auto_detect(self):
signal = Signal(get_path_for_data_file("wsp.complex"), "test")
signal.modulation_type = 0
signal.noise_threshold = 0.035
signal.qad_center = 0.0245
signal.bit_len = 25
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
start, num_samples = pa.get_samplepos_of_bitseq(0, 0, 0, 999999, include_pause=False)
print("-----------")
print(signal.estimate_frequency(start, end=start+num_samples, sample_rate=2e6))
def test_ask_two(self):
signal = Signal(get_path_for_data_file("ask_short.complex"), "ASK-Test2")
signal.modulation_type = "ASK"
signal.noise_threshold = 0.0299
signal.samples_per_symbol = 16
signal.center = 0.1300
signal.tolerance = 0
self.assertEqual(signal.num_samples, 131)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.plain_bits_str[0], "10101010")
def __demodulate(self, connection):
QTest.qWait(100)
data = connection.recv(65536)
while len(data) % 8 != 0:
data += connection.recv(65536)
arr = np.array(np.frombuffer(data, dtype=np.complex64))
signal = Signal("", "")
signal._fulldata = arr
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
return pa.plain_bits_str
def __init__(self,
samples_per_symbol: int,
center: float,
center_spacing: float,
noise: float,
tolerance: int,
modulation_type: str,
bits_per_symbol: int,
device: str,
backend_handler: BackendHandler,
network_raw_mode=False):
signal = Signal("", "LiveSignal")
signal.samples_per_symbol = samples_per_symbol
signal.center = center
signal.center_spacing = center_spacing
signal.noise_threshold = noise
signal.tolerance = tolerance
signal.silent_set_modulation_type(modulation_type)
signal.bits_per_symbol = bits_per_symbol
ProtocolAnalyzer.__init__(self, signal)
QObject.__init__(self, None)
self.network_raw_mode = network_raw_mode
self.backend_handler = backend_handler
self.rcv_device = VirtualDevice(self.backend_handler,
device,
Mode.receive,
resume_on_full_receive_buffer=True,
raw_mode=network_raw_mode)
signal.iq_array = IQArray(None, self.rcv_device.data_type, 0)
self.sniff_thread = Thread(target=self.check_for_data, daemon=True)
self.rcv_device.started.connect(self.__emit_started)
self.rcv_device.stopped.connect(self.__emit_stopped)
self.__buffer = IQArray(None, np.float32, 0)
self.__init_buffer()
self.__current_buffer_index = 0
self.reading_data = False
self.adaptive_noise = False
self.automatic_center = False
self.pause_length = 0
self.is_running = False
self.store_messages = True
self.__sniff_file = ""
self.__store_data = True
def test_fsk(self):
signal = Signal("./data/fsk.complex", "FSK-Test")
QTest.qWait(100)
signal.modulation_type = 1
signal.bit_len = 100
signal.qad_center = 0
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(
proto_analyzer.plain_bits_str[0],
"101010101010101010101010101010101100011000100110110001100010011011110100110111000001110110011000111011101111011110100100001001111001100110011100110100100011100111010011111100011"
)
def test_get_rssi_of_message(self):
signal = Signal(get_path_for_data_file("two_participants.coco"), "RSSI-Test")
signal.modulation_type = 1
signal.bit_len = 100
signal.qad_center = -0.0507
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_messages, 18)
messages = proto_analyzer.messages
self.assertLess(messages[0].rssi, messages[1].rssi)
self.assertGreater(messages[1].rssi, messages[2].rssi)
self.assertLess(messages[2].rssi, messages[3].rssi)
self.assertLess(messages[-2].rssi, messages[-1].rssi)
def demodulate(signal_data, mod_type: str, bit_length, center, noise, tolerance, decoding=None, pause_threshold=8):
signal = Signal("", "")
signal._fulldata = signal_data
signal.modulation_type = signal.MODULATION_TYPES.index(mod_type)
signal.bit_len = bit_length
signal.qad_center = center
signal.noise_threshold = noise
signal.pause_threshold = pause_threshold
if tolerance is not None:
signal.tolerance = tolerance
pa = ProtocolAnalyzer(signal)
if decoding is not None:
pa.decoder = decoding
pa.get_protocol_from_signal()
return pa.decoded_hex_str
def read_messages_to_send(arguments: argparse.Namespace):
if not arguments.transmit:
return None
if arguments.messages is not None and arguments.filename is not None:
print("Either give messages (-m) or a file to read from (-file) not both.")
sys.exit(1)
elif arguments.messages is not None:
#support for calls from external tools e.g. metasploit
if len(arguments.messages) == 1:
message_strings = arguments.messages[0].split(' ')
else:
message_strings = arguments.messages
elif arguments.filename is not None:
with open(arguments.filename) as f:
message_strings = list(map(str.strip, f.readlines()))
else:
print("You need to give messages to send either with (-m) or a file (-file) to read them from.")
sys.exit(1)
encoding = build_encoding_from_args(arguments)
result = ProtocolAnalyzer.get_protocol_from_string(message_strings, is_hex=arguments.hex,
default_pause=arguments.pause,
sample_rate=arguments.sample_rate).messages
if encoding:
for msg in result:
msg.decoder = encoding
return result
def setUp(self):
self.protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("decoded_bits.txt")) as f:
for line in f:
self.protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.protocol.messages[-1].message_type = self.protocol.default_message_type
# Assign participants
alice = Participant("Alice", "A")
bob = Participant("Bob", "B")
alice_indices = {1,2,5,6,9,10,13,14,17,18,20,22,23,26,27,30,31,34,35,38,39,41}
for i, message in enumerate(self.protocol.messages):
if i in alice_indices:
message.participant = alice
else:
message.participant = bob
self.assertEqual(self.protocol.num_messages, 42)
self.assertEqual(self.protocol.plain_hex_str[0][16:18], "2d")
self.decodings = []
self.decodings.append(Encoding(['Non Return To Zero (NRZ)']))
self.decodings.append(Encoding(['Non Return To Zero Inverted (NRZ-I)', 'Invert']))
self.decodings.append(Encoding(['Manchester I', 'Edge Trigger']))
self.decodings.append(Encoding(['Manchester II', 'Edge Trigger', 'Invert']))
self.decodings.append(Encoding(['Differential Manchester', 'Edge Trigger', 'Differential Encoding', ]))
self.decodings.append(Encoding(['DeWhitening Special', constants.DECODING_DATAWHITENING, '0x9a7d9a7d;0x21']))
self.decodings.append(Encoding(['DeWhitening', constants.DECODING_DATAWHITENING, '0x67686768;0x21']))
def on_simulator_open_in_analysis_requested(self, text: str):
protocol = ProtocolAnalyzer.get_protocol_from_string(text.split("\n"))
protocol.name = "Transcript"
self.ui.tabWidget.setCurrentIndex(1)
self.compare_frame_controller.add_protocol(protocol)
self.compare_frame_controller.refresh()
def test_write(self):
signal = Signal(get_path_for_data_file("ask.complex"), "ASK-Test")
signal.modulation_type = 0
signal.bit_len = 295
signal.qad_center = -0.1667
self.assertEqual(signal.num_samples, 13710)
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.decoded_hex_str[0], "b25b6db6c80")
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
proto_analyzer.messages.append(copy.deepcopy(proto_analyzer.messages[0]))
pcap = PCAP()
pcap.write_packets(proto_analyzer.messages, os.path.join(tempfile.gettempdir(), "test.pcap"), 1e6)
def test_freq_detection(self):
s = Signal(get_path_for_data_file("steckdose_anlernen.complex"), "RWE")
s.noise_threshold = 0.06
s.qad_center = 0
s.bit_len = 100
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(pa.messages[0].plain_bits_str,
"101010101010101010101010101010101001101001111101100110100111110111010010011000010110110101111"
"010111011011000011000101000010001001101100101111010110100110011100100110000101001110100001111"
"111101000111001110000101110100100111010110110100001101101101010100011011010001010110011100011"
"010100010101111110011010011001000000110010011010001000100100100111101110110010011111011100010"
"10110010100011111101110111000010111100111101001011101101011011010110101011100")
start, nsamples = pa.get_samplepos_of_bitseq(0, 0, 0, 1, False)
freq = s.estimate_frequency(start, start + nsamples, 1e6)
self.assertEqual(freq, 10000) # Freq for 1 is 10K
def test_gfsk(self):
target_file = os.path.join(tempfile.gettempdir(), "test.complex")
modulator = Modulator("gfsk")
modulator.modulation_type_str = "FSK"
modulator.samples_per_bit = 100
modulator.sample_rate = 1e6
modulator.param_for_one = 20e3
modulator.param_for_zero = -10e3
data1 = modulator.modulate([True, False, False, True, False], 9437)
data2 = modulator.modulate([True, False, True], 9845) #, start=len(s))
data3 = modulator.modulate([True, False, True, False], 8457) #, start=len(s))
s = np.concatenate((data1, data2, data3))
s.tofile(target_file)
pa = ProtocolAnalyzer(Signal(target_file, "test", modulation="FSK"))
pa.get_protocol_from_signal()
def test_fsk_freq_detection(self):
s = Signal(get_path_for_data_file("steckdose_anlernen.complex"), "RWE")
s.noise_threshold = 0.06
s.qad_center = 0
s.bit_len = 100
pa = ProtocolAnalyzer(s)
pa.get_protocol_from_signal()
self.assertEqual(pa.messages[0].plain_bits_str,
"101010101010101010101010101010101001101001111101100110100111110111010010011000010110110101111"
"010111011011000011000101000010001001101100101111010110100110011100100110000101001110100001111"
"111101000111001110000101110100100111010110110100001101101101010100011011010001010110011100011"
"010100010101111110011010011001000000110010011010001000100100100111101110110010011111011100010"
"10110010100011111101110111000010111100111101001011101101011011010110101011100")
freq = pa.estimate_frequency_for_one(1e6)
self.assertAlmostEqual(1, freq / 10000, places = 1) # Freq for 1 is 10K
freq = pa.estimate_frequency_for_zero(1e6)
self.assertAlmostEqual(3, freq / 10000, places = 1) # Freq for 0 is 30K
def __init__(self, proto_analyzer: ProtocolAnalyzer, index: int, rows: list, view: int):
super().__init__()
self.proto_analyzer = proto_analyzer
self.index = proto_analyzer.convert_index(index, from_view=view, to_view=0, decoded=False)[0]
self.nbits = 1 if view == 0 else 4 if view == 1 else 8
self.rows = rows
self.saved_messages = {}
self.setText("Insert column at {0:d}".format(index))
def add_plain_bits_from_txt(self, filename: str):
with open(filename) as f:
protocol = ProtocolAnalyzer.get_protocol_from_string(f.readlines())
protocol.filename = filename
protocol.name = util.get_name_from_filename(filename)
self.compare_frame_controller.add_protocol(protocol)
self.compare_frame_controller.refresh()
self.__add_empty_frame_for_filename(protocol, filename)
def test_assign_decodings(self):
self.undecoded_protocol = ProtocolAnalyzer(None)
with open(get_path_for_data_file("undecoded.txt")) as f:
for line in f:
self.undecoded_protocol.messages.append(Message.from_plain_bits_str(line.replace("\n", "")))
self.undecoded_protocol.auto_assign_decodings(self.decodings)
for i, message in enumerate(self.undecoded_protocol.messages):
if message.plain_hex_str[8:16] == "9a7d9a7d":
self.assertEqual(message.decoder.name, "DeWhitening Special", msg=str(i))
elif message.plain_hex_str[8:16] == "67686768":
self.assertEqual(message.decoder.name, "DeWhitening", msg=str(i))
def test_ask_fsk_psk_modulation(self):
modulations = ["ASK", "FSK", "PSK"]
for i, modulation in enumerate(modulations):
modulator = Modulator(modulation)
tmp_dir = QDir.tempPath()
filename = "{0}_mod.complex".format(modulation)
filename = os.path.join(tmp_dir, filename)
modulator.modulation_type = i
modulator.samples_per_bit = self.samples_per_bit
if modulation == "ASK":
modulator.param_for_zero = 0
modulator.param_for_one = 100
elif modulation == "FSK":
modulator.param_for_zero = 1000
modulator.param_for_one = 2500
elif modulation == "PSK":
modulator.param_for_zero = 0
modulator.param_for_one = 180
modulator.modulate(self.modulation_data, self.pause)
modulator.modulated_samples.tofile(filename)
signal = Signal(filename, modulation)
signal.modulation_type = i
signal.bit_len = self.samples_per_bit
if modulation == "ASK":
signal.qad_center = 0.5
elif modulation == "FSK":
signal.qad_center = 0.0097
elif modulation == "PSK":
signal.qad_center = 0
self.assertEqual(signal.num_samples, self.total_samples, msg=modulation)
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.assertEqual(1, len(pa.messages), msg=modulation)
self.assertEqual(self.modulation_data, pa.messages[0].plain_bits, msg=modulation)
