class QDebugPanel(QMainWindow):
def __init__(self, app, flags=None):
super(QDebugPanel, self).__init__(flags)
self.setDockOptions(QMainWindow.AnimatedDocks
| QMainWindow.AllowNestedDocks
| QMainWindow.AllowTabbedDocks)
self.app = app
self.q_settings = app.q_settings
screen_size = QtWidgets.QDesktopWidget().screenGeometry(-1)
m_width = screen_size.width()
self.memory_panel = HexEditor(self.app)
self.memory_panel.debug_panel = self
self.memory_panel.dataChanged.connect(self.on_memory_modified)
self.disassembly_panel = DisassemblyView(self.app)
self.disassembly_panel.debug_panel = self
self.dock_memory_panel = QDockWidget('Memory', self)
self.dock_memory_panel.setWidget(self.memory_panel)
self.dock_memory_panel.setObjectName('memory')
self.dock_disassembly_panel = QDockWidget('Disassembly', self)
self.dock_disassembly_panel.setWidget(self.disassembly_panel)
self.dock_disassembly_panel.setObjectName('disassembly')
self.addDockWidget(Qt.LeftDockWidgetArea, self.dock_memory_panel,
Qt.Horizontal)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dock_disassembly_panel,
Qt.Horizontal)
if m_width >= 1920:
self.splitDockWidget(self.dock_memory_panel,
self.dock_disassembly_panel, Qt.Horizontal)
else:
self.tabifyDockWidget(self.dock_memory_panel,
self.dock_disassembly_panel)
self.restoreUiState()
def restoreUiState(self):
ui_state = self.q_settings.value('dwarf_debug_ui_state')
if ui_state:
self.restoreGeometry(ui_state)
window_state = self.q_settings.value('dwarf_debug_ui_window')
if window_state:
self.restoreState(window_state)
def closeEvent(self, event):
self.q_settings.setValue('dwarf_debug_ui_state', self.saveGeometry())
self.q_settings.setValue('dwarf_debug_ui_window', self.saveState())
def showEvent(self, event):
main_width = self.size().width()
new_widths = [main_width * .4, main_width * .5]
self.resizeDocks([self.dock_memory_panel, self.dock_disassembly_panel],
new_widths, Qt.Horizontal)
return super().showEvent(event)
def update_functions(self, functions_list=None):
if functions_list is None:
functions_list = {}
for module_info_base in self.app.dwarf.database.modules_info:
module_info = self.app.dwarf.database.modules_info[
module_info_base]
if len(module_info.functions) > 0:
for function in module_info.functions:
functions_list[function.name] = function.address
for function_name in sorted(functions_list.keys()):
function_addr = functions_list[function_name]
function_name = function_name.replace('.', '_')
if not self.app.bookmarks_panel.is_address_bookmarked(
function_addr):
self.app.bookmarks_panel._create_bookmark(ptr=function_addr,
note=function_name)
def on_context_setup(self):
self.memory_panel.on_context_setup()
def on_memory_modified(self, pos, length):
data_pos = self.memory_panel.base + pos
data = self.memory_panel.data[pos:pos + length]
data = [data[0]] # todo: strange js part
if self.dwarf.dwarf_api('writeBytes', [data_pos, data]):
pass
else:
utils.show_message_box('Failed to write Memory')
def raise_memory_panel(self):
self.dock_memory_panel.raise_()
def raise_disassembly_panel(self):
self.dock_disassembly_panel.raise_()
def jump_to_address(self, address, view=DEBUG_VIEW_MEMORY):
address = utils.parse_ptr(address)
if view == DEBUG_VIEW_MEMORY:
if self.memory_panel.number_of_lines() > 0:
if self.is_address_in_view(view, address):
return
elif view == DEBUG_VIEW_DISASSEMBLY:
if self.disassembly_panel.number_of_lines() > 0:
if self.is_address_in_view(view, address):
return
self.app.show_progress('reading data...')
self.app.dwarf.read_range_async(
address, lambda base, data, offset: self._apply_data(
base, data, offset, view=view))
def _apply_data(self, base, data, offset, view=DEBUG_VIEW_MEMORY):
self.app.hide_progress()
self.update_functions()
if view == DEBUG_VIEW_MEMORY:
self.memory_panel.set_data(data, base=base, offset=offset)
if not self.dock_memory_panel.isVisible():
self.dock_memory_panel.show()
self.raise_memory_panel()
if self.disassembly_panel.number_of_lines() == 0:
self.disassembly_panel.disasm(base, data, offset)
elif view == DEBUG_VIEW_DISASSEMBLY:
self.disassembly_panel.disasm(base, data, offset)
if not self.dock_disassembly_panel.isVisible():
self.dock_disassembly_panel.show()
self.raise_disassembly_panel()
if self.memory_panel.number_of_lines() == 0:
self.memory_panel.set_data(data, base=base, offset=offset)
def is_address_in_view(self, view, address):
if view == DEBUG_VIEW_MEMORY:
if self.memory_panel.data:
ptr_exists = self.memory_panel.base <= address <= self.memory_panel.base + len(
self.memory_panel.data)
if ptr_exists:
self.memory_panel.caret.position = address - self.memory_panel.base
return True
elif view == DEBUG_VIEW_DISASSEMBLY:
if self.disassembly_panel.visible_lines() > 0:
line_index_for_address = self.disassembly_panel.get_line_for_address(
address)
if line_index_for_address >= 0:
self.disassembly_panel.highlighted_line = line_index_for_address
self.disassembly_panel.verticalScrollBar().setValue(
line_index_for_address)
return True
return False
def on_cm_jump_to_address(self, view=DEBUG_VIEW_MEMORY):
ptr, _ = InputDialog.input_pointer(self.app)
if ptr > 0:
self.jump_to_address(ptr, view=view)
def dump_data(self, address, _len):
def _dump(ptr, data):
if data is not None:
from PyQt5.QtWidgets import QFileDialog
_file = QFileDialog.getSaveFileName(self.app)
with open(_file[0], 'wb') as f:
f.write(data)
self.app.dwarf.read_memory_async(address, _len, _dump)
class DataPanel(QSplitter):
def __init__(self, app):
super(DataPanel, self).__init__(app)
self.app = app
self.data = {}
self.setOrientation(Qt.Horizontal)
self._key_list_model = QStandardItemModel(0, 1)
self.key_lists = DwarfListView(parent=self.app)
self.key_lists.setHeaderHidden(True)
self.key_lists.setModel(self._key_list_model)
self.key_lists.selectionModel().selectionChanged.connect(
self.item_selected)
self.key_lists.setContextMenuPolicy(Qt.CustomContextMenu)
self.key_lists.customContextMenuRequested.connect(
self._on_context_menu)
self.addWidget(self.key_lists)
self.editor = QPlainTextEdit()
self.addWidget(self.editor)
self.hex_view = HexEditor(self.app)
self.hex_view.have_context_menu = False
self.hex_view.setVisible(False)
self.addWidget(self.hex_view)
#self.setStretchFactor(0, 8)
self.setStretchFactor(1, 4)
self.setStretchFactor(2, 4)
def clear(self):
self._key_list_model.clear()
self.editor.setPlainText('')
self.hex_view.clear_panel()
def append_data(self, data_type, key, text_data):
if key not in self.data:
self._key_list_model.appendRow([QStandardItem(key)])
self.data[key] = [data_type, text_data]
def item_selected(self, item1, item2):
item = self._key_list_model.itemFromIndex(item1.indexes()[0])
if self.data[item.text()][0] == 'plain':
self.hex_view.setVisible(False)
self.editor.setVisible(True)
self.editor.setPlainText(self.data[item.text()][1])
else:
data = self.data[item.text()][1]
try:
as_tx = data.decode('utf8')
self.editor.setVisible(True)
self.editor.setPlainText(as_tx)
except:
self.editor.setVisible(False)
self.hex_view.setVisible(True)
self.hex_view.bytes_per_line = 16
self.hex_view.set_data(data)
def _on_context_menu(self, pos):
context_menu = QMenu(self)
index = self.key_lists.indexAt(pos).row()
if index != -1:
context_menu.addAction('Clear', self.clear)
global_pt = self.key_lists.mapToGlobal(pos)
context_menu.exec(global_pt)