def execute(self, main_window, trace_data, selected_row_ids):

        add_bookmarks = main_window.ask_user(
            "Add to bookmarks", "Add found writes to bookmarks?"
        )

        trace = main_window.get_visible_trace()
        trace_length = len(trace)
        main_window.print('Length of visible trace: %d' % trace_length)

        ip_reg_name = trace_data.get_instruction_pointer_name()
        ip_reg_index = trace_data.get_reg_index(ip_reg_name)
        row = 0

        while 1:
            row = find(
                trace=trace,
                field=TraceField.MEM,
                keyword='WRITE',
                start_row=row,
            )

            if row is None or row > trace_length:
                main_window.print('End of search')
                break

            address = hex(trace[row]['regs'][ip_reg_index])

            # convert all written values to hex string
            mems = []
            for mem in trace[row]['mem']:
                if mem['access'] == 'WRITE':
                    mems.append(mem)
            values = " ".join([hex(mem['value']) for mem in mems])

            bookmark = Bookmark(
                startrow=row,
                endrow=row,
                addr=address,
                disasm=trace[row]['disasm'],
                comment=values
            )

            main_window.print(
                f"mem write found at {row}, values: {values}"
            )

            if add_bookmarks:
                trace_data.add_bookmark(bookmark, replace=False)
            row += 1

        main_window.update_bookmark_table()
Esempio n. 2
0
    def on_find_btn_clicked(self, keyword: str, field_index: int,
                            direction: int):
        """Find next or prev button clicked"""
        current_row = self.trace_table.currentRow()
        if current_row < 0:
            current_row = 0

        if self.trace_table.pagination is not None:
            pagination = self.trace_table.pagination
            page = pagination.current_page
            rows_per_page = pagination.rows_per_page
            current_row += (page - 1) * rows_per_page

        if field_index == 0:
            field = TraceField.DISASM
        elif field_index == 1:
            field = TraceField.REGS
        elif field_index == 2:
            field = TraceField.MEM
        elif field_index == 3:
            field = TraceField.MEM_ADDR
        elif field_index == 4:
            field = TraceField.MEM_VALUE
        elif field_index == 5:
            field = TraceField.COMMENT
        elif field_index == 6:
            field = TraceField.ANY

        try:
            row_number = find(
                trace=self.get_visible_trace(),
                field=field,
                keyword=keyword,
                start_row=current_row + direction,
                direction=direction,
            )
        except Exception as exc:
            self.show_messagebox("Find error", f"{exc}")
            print(traceback.format_exc())
            self.print(traceback.format_exc())
            return

        if row_number is not None:
            self.trace_table.go_to_row(row_number)
        else:
            print_debug(
                f"{keyword} not found (row: {current_row}, direction: {direction})"
            )
Esempio n. 3
0
    def on_find_clicked(self, direction):
        """Find next or prev button clicked"""

        row = self.trace_table.currentRow()
        if row < 0:
            row = 0

        keyword = self.search_edit.text()
        index = self.find_combo_box.currentIndex()
        if index == 0:
            field = TraceField.DISASM
        elif index == 1:
            field = TraceField.REGS
        elif index == 2:
            field = TraceField.MEM
        elif index == 3:
            field = TraceField.MEM_ADDR
        elif index == 4:
            field = TraceField.MEM_VALUE
        elif index == 5:
            field = TraceField.COMMENT
        elif index == 6:
            field = TraceField.ANY

        try:
            row_number = find(
                trace=self.get_visible_trace(),
                field=field,
                keyword=keyword,
                start_row=row + direction,
                direction=direction,
            )
        except Exception as exc:
            print("Error on find: " + str(exc))
            print(traceback.format_exc())
            self.print(traceback.format_exc())
            return

        if row_number is not None:
            self.goto_row(self.trace_table, row_number)
            self.select_row(self.trace_table, row_number)
        else:
            print_debug("%s not found (row %d, direction %d)" %
                        (keyword, row, direction))