def cb_process_run(bv):
def switch_view():
dh = DockHandler.getActiveDockHandler()
vf = dh.getViewFrame()
vf.setViewType('Debugger:' + bv.view_type)
debug_state = binjaplug.get_state(bv)
if debug_state.ui.debug_view is None:
execute_on_main_thread_and_wait(switch_view)
if debug_state.ui.debug_view is not None:
debug_state.ui.debug_view.controls.actionRun.trigger()
def unmap_memory(self, start: int, length: int) -> None:
memory: BinaryView = self.view.session_data.get("emulator.memory.view")
if memory is None:
raise KeyError("Memory View not found")
# TODO
# Implement page tables oh god
# Otherwise we're gonna blow up memory every time we map
# something and unmap it
execute_on_main_thread_and_wait(
self.view.session_data["emulator.memory.model"].beginResetModel)
memory.remove_user_segment(start, length)
execute_on_main_thread_and_wait(
self.view.session_data["emulator.memory.model"].endResetModel)
def perform_attach_thread():
try:
self.debug_state.attach()
execute_on_main_thread_and_wait(perform_attach_after)
except ConnectionRefusedError:
execute_on_main_thread_and_wait(
lambda: perform_attach_error('ERROR: Connection Refused'))
except TimeoutError:
execute_on_main_thread_and_wait(
lambda: perform_attach_error('ERROR: Connection Refused'))
except Exception as e:
execute_on_main_thread_and_wait(
lambda: perform_attach_error('ERROR: ' + ' '.join(e.args)))
traceback.print_exc(file=sys.stderr)
def perform_step_return_thread():
(reason, data) = self.debug_state.step_return()
execute_on_main_thread_and_wait(
lambda: self.handle_stop_return(reason, data))
execute_on_main_thread_and_wait(
lambda: self.debug_state.ui.context_display())
def perform_step_return_thread():
(reason, data) = self.debug_state.step_return()
execute_on_main_thread_and_wait(
lambda: perform_step_return_after(reason, data))
def perform_step_over_il_thread():
(reason, data) = self.debug_state.step_over(graph_type)
execute_on_main_thread_and_wait(
lambda: perform_step_over_il_after(reason, data))
def perform_resume_thread():
(reason, data) = self.debug_state.go()
execute_on_main_thread_and_wait(
lambda: perform_resume_after(reason, data))
def perform_run_thread():
while True:
try:
self.debug_state.run()
execute_on_main_thread_and_wait(perform_run_after)
except ConnectionRefusedError:
execute_on_main_thread_and_wait(
lambda: perform_run_error('ERROR: Connection Refused'))
except DebugAdapter.ProcessStartError as e:
execute_on_main_thread_and_wait(
lambda: perform_run_error(str(e)))
except DebugAdapter.NotExecutableError as e:
fpath = e.args[0]
if platform.system() != 'Windows':
msg = '%s is not executable, would you like to set +x and retry?' % fpath
res = show_message_box(
'Error', msg, MessageBoxButtonSet.YesNoButtonSet,
MessageBoxIcon.ErrorIcon)
if res == MessageBoxButtonResult.YesButton:
os.chmod(fpath, os.stat(fpath).st_mode | 0o100)
continue
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: Target Not Executable'))
except DebugAdapter.NotInstalledError as e:
execute_on_main_thread_and_wait(
lambda: self.alert_need_install(e.args[0]))
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: Debugger Not Installed'))
except DebugAdapter.PermissionDeniedError as e:
execute_on_main_thread_and_wait(
lambda: perform_run_error('ERROR: Permission denied'))
if platform.system() == 'Darwin':
res = show_message_box(
'Error',
'Developer tools need to be enabled to debug programs. This can be authorized either from here or by starting a debugger in Xcode.',
MessageBoxButtonSet.OKButtonSet,
MessageBoxIcon.ErrorIcon)
except Exception as e:
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: ' + ' '.join(e.args)))
traceback.print_exc(file=sys.stderr)
break
def on_stdout(self, output):
def on_stdout_main_thread(output):
console_widget = self.widget('Debugger Console')
console_widget.notifyStdout(output)
execute_on_main_thread_and_wait(lambda: on_stdout_main_thread(output))
def write_register(self, reg_name: str, value: int):
registers = self.view.session_data.get("emulator.registers", [])
if not registers:
self.view.session_data["emulator.registers"] = registers
regs = {
r[0]: (i, r[1])
for i, r in enumerate(
self.view.session_data.get("emulator.registers", []))
}
if reg_name.startswith('temp'):
register = RegisterInfo(reg_name, self.view.address_size)
else:
register = self.view.arch.regs[reg_name]
size = register.size
offset = register.offset
extend = register.extend
full_width_reg = register.full_width_reg
if full_width_reg == reg_name:
if not regs or reg_name.startswith('temp'):
regs[reg_name] = (0, None)
execute_on_main_thread_and_wait(
self.view.session_data["emulator.registers.model"].startUpdate)
registers[regs[reg_name][0]] = (reg_name, value)
execute_on_main_thread_and_wait(
self.view.session_data["emulator.registers.model"].endUpdate)
if reg_name == self.view.arch.stack_pointer:
execute_on_main_thread_and_wait(lambda: self.view.session_data[
'emulator.stack.model'].update(value))
return
full_width_value = self.read_register(full_width_reg)
mask = (1 << (offset * 8)) - 1
mask ^= (1 << ((size + offset) * 8)) - 1
shifted_value = value << (offset * 8)
masked_value = shifted_value & mask
full_width_size = self.view.arch.regs[full_width_reg].size
full_width_mask = (1 << (full_width_size * 8)) - 1
full_width_mask ^= mask
if extend == ImplicitRegisterExtend.NoExtend:
full_width_value = masked_value | (full_width_mask
& full_width_value)
elif extend == ImplicitRegisterExtend.ZeroExtendToFullWidth:
full_width_value = masked_value | (full_width_value &
((1 <<
((size + offset) * 8)) - 1))
elif extend == ImplicitRegisterExtend.SignExtendToFullWidth:
sign_bit = shifted_value & (1 << ((size + offset - 1) * 8))
full_width_value = masked_value | (full_width_value &
((1 <<
((size + offset) * 8)) - 1))
if sign_bit:
full_width_value |= full_width_mask ^ ((1 << (
(size + offset) * 8)) - 1)
if not regs:
regs[full_width_reg] = (full_width_reg, full_width_value)
execute_on_main_thread_and_wait(
self.view.session_data["emulator.registers.model"].startUpdate)
registers[regs[full_width_reg][0]] = (full_width_reg, full_width_value)
execute_on_main_thread_and_wait(
self.view.session_data["emulator.registers.model"].endUpdate)
def perform_run_thread():
while True:
try:
self.debug_state.run()
execute_on_main_thread_and_wait(perform_run_after)
except ConnectionRefusedError:
execute_on_main_thread_and_wait(
lambda: perform_run_error('ERROR: Connection Refused'))
except DebugAdapter.NotExecutableError as e:
fpath = e.args[0]
if platform.system() != 'Windows':
msg = '%s is not executable, would you like to set +x and retry?' % fpath
res = show_message_box(
'Error', msg, MessageBoxButtonSet.YesNoButtonSet,
MessageBoxIcon.ErrorIcon)
if res == MessageBoxButtonResult.YesButton:
os.chmod(fpath, os.stat(fpath).st_mode | 0o100)
continue
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: Target Not Executable'))
except DebugAdapter.NotInstalledError as e:
execute_on_main_thread_and_wait(
lambda: self.alert_need_install(e.args[0]))
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: Debugger Not Installed'))
except Exception as e:
execute_on_main_thread_and_wait(lambda: perform_run_error(
'ERROR: ' + ' '.join(e.args)))
traceback.print_exc(file=sys.stderr)
break
def signal_sync_done(bv, _results):
""" Callback designed to run the update_wrapper function again immediately after we've had our first successful sync
after being unable to succesfully sync. Has to run on the main thread to prevent a crash. The outer lambda function
calls the update wrapper, while the inner lambda function acts as a stub so that wrapped() doesn't fail. """
execute_on_main_thread_and_wait(lambda: update_wrapper(
lambda _: log_info("Called update wrapper within callback"), bv))
