IDA PRO 9.1 + Python 3.11 + Pin 3.31 Support + Deadlock Fix

plugins/tenet/integration/api/ida_api.py

@@ -22,6 +22,7 @@
 import ida_diskio
 import ida_kernwin
 import ida_segment
+import ida_ida
 
 from .api import DisassemblerCoreAPI, DisassemblerContextAPI
 from ...util.qt import *
@@ -198,9 +199,9 @@ def get_processor_type(self):
         pass
 
     def is_64bit(self):
-        inf = ida_idaapi.get_inf_structure()
-        #target_filetype = inf.filetype
-        return inf.is_64bit()
+        # The get_inf_structure() function is deprecated in newer IDA versions.
+        # The 'inf' object is now directly accessible via ida_ida.
+        return ida_ida.inf_is_64bit()
 
     def is_call_insn(self, address):
         insn = ida_ua.insn_t()

plugins/tenet/ui/hex_view.py

@@ -197,7 +197,7 @@ def _refresh_painting_metrics(self):
         self._width_aux = (self.model.num_bytes_per_line * self._char_width) + self._char_width * 2
 
         # enforce a minimum view width, to ensure all text stays visible
-        self.setMinimumWidth(self._pos_aux + self._width_aux)
+        self.setMinimumWidth(int(self._pos_aux + self._width_aux))
 
     def full_size(self):
         """
@@ -206,7 +206,7 @@ def full_size(self):
         if not self.model.data:
             return QtCore.QSize(0, 0)
 
-        width = self._pos_aux + (self.model.num_bytes_per_line * self._char_width)
+        width = int(self._pos_aux + (self.model.num_bytes_per_line * self._char_width))
         height = len(self.model.data) // self.model.num_bytes_per_line
         if len(self.model.data) % self.model.num_bytes_per_line:
             height += 1
@@ -694,17 +694,17 @@ def paintEvent(self, event):
         painter.fillRect(event.rect(), self._palette.hex_data_bg)
 
         # paint address area background
-        address_area_rect = QtCore.QRect(0, event.rect().top(), self._width_addr, self.height())
+        address_area_rect = QtCore.QRect(0, event.rect().top(), int(self._width_addr), self.height())
         painter.fillRect(address_area_rect, self._palette.hex_address_bg)
 
         # paint line between address area and hex area
         painter.setPen(self._palette.hex_separator)
-        painter.drawLine(self._width_addr, event.rect().top(), self._width_addr, self.height())
+        painter.drawLine(int(self._width_addr), event.rect().top(), int(self._width_addr), self.height())
 
         # paint line between hex area and auxillary area
         line_pos = self._pos_aux
         painter.setPen(self._palette.hex_separator)
-        painter.drawLine(line_pos, event.rect().top(), line_pos, self.height())
+        painter.drawLine(int(line_pos), event.rect().top(), int(line_pos), self.height())
 
         for line_idx in range(0, self.num_lines_visible):
             self._paint_line(painter, line_idx)
@@ -735,7 +735,7 @@ def _paint_line(self, painter, line_idx):
         pack_len = self.model.pointer_size
         address_fmt = '%016X' if pack_len == 8 else '%08X'
         address_text = address_fmt % address
-        painter.drawText(self._pos_addr, y, address_text)
+        painter.drawText(int(self._pos_addr), y, address_text)
 
         self._default_color = self._palette.hex_text_fg
         if address < self.model.fade_address:
@@ -775,7 +775,7 @@ def _paint_line(self, painter, line_idx):
                 else:
                     ch = chr(ch)
 
-                painter.drawText(x_pos_aux, y, ch)
+                painter.drawText(int(x_pos_aux), y, ch)
                 x_pos_aux += self._char_width
 
     def _paint_hex_item(self, painter, byte_idx, stop_idx, x, y):
@@ -960,15 +960,15 @@ def _paint_text(self, painter, byte_idx, padding, x, y):
                 painter.setPen(QtCore.Qt.NoPen)
 
             painter.setBrush(bg_color)
-            painter.drawRect(x_bg, y_bg, width, height)
+            painter.drawRect(int(x_bg), int(y_bg), int(width), int(height))
 
         painter.setPen(fg_color)
 
         #
         # paint text
         #
 
-        painter.drawText(x, y, text)
+        painter.drawText(int(x), y, text)
 
     def _paint_magic(self, painter, byte_idx, stop_idx, x, y):
         """
@@ -1006,7 +1006,7 @@ def _paint_magic(self, painter, byte_idx, stop_idx, x, y):
 
         # draw the pointer
         pointer_str = ("0x%08X " % value).rjust(num_chars)
-        painter.drawText(x, y, pointer_str)
+        painter.drawText(int(x), y, pointer_str)
         x += num_chars * self._char_width
 
         return (byte_idx + self.model.pointer_size, x, y)

plugins/tenet/ui/reg_view.py

@@ -109,7 +109,7 @@ def __init__(self, controller, model, parent=None):
 
         self.setFocusPolicy(QtCore.Qt.StrongFocus)
         self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
-        self.setMinimumWidth(self._reg_pos[0] + self._default_width)
+        self.setMinimumWidth(int(self._reg_pos[0] + self._default_width))
         self.setMouseTracking(True)
 
         self._init_ctx_menu()
@@ -118,8 +118,8 @@ def __init__(self, controller, model, parent=None):
         self.model.registers_changed(self.refresh)
 
     def sizeHint(self):
-        width = self._default_width
-        height = (len(self._reg_fields) + 2) * self._char_height # +2 for line break before IP, and after IP
+        width = int(self._default_width)
+        height = int((len(self._reg_fields) + 2) * self._char_height) # +2 for line break before IP, and after IP
         return QtCore.QSize(width, height)
 
     def _init_ctx_menu(self):
@@ -152,7 +152,7 @@ def _init_reg_positions(self):
         fm = QtGui.QFontMetricsF(self.font())
         name_size = fm.boundingRect('X'*common_count).size()
         value_size = fm.boundingRect('0' * (self.model.arch.POINTER_SIZE * 2)).size()
-        arrow_size = (int(value_size.height() * 0.70) & 0xFE) + 1
+        arrow_size = (int(value_size.height() * 0.70) | 1)
 
         # pre-compute the position of each register in the window
         for reg_name in regs:
@@ -162,24 +162,24 @@ def _init_reg_positions(self):
             if reg_name == self.model.arch.IP:
                 y += self._char_height
 
-            name_rect = QtCore.QRect(0, 0, name_size.width(), name_size.height())
-            name_rect.moveBottomLeft(QtCore.QPoint(name_x, y))
+            name_rect = QtCore.QRect(0, 0, int(name_size.width()), int(name_size.height()))
+            name_rect.moveBottomLeft(QtCore.QPoint(int(name_x), int(y)))
 
-            prev_rect = QtCore.QRect(0, 0, arrow_size, arrow_size)
-            next_rect = QtCore.QRect(0, 0, arrow_size, arrow_size)
+            prev_rect = QtCore.QRect(0, 0, int(arrow_size), int(arrow_size))
+            next_rect = QtCore.QRect(0, 0, int(arrow_size), int(arrow_size))
             arrow_rects = [prev_rect, next_rect]
 
             prev_x = name_x + name_size.width() + self._char_width
             prev_rect.moveCenter(name_rect.center())
-            prev_rect.moveLeft(prev_x)
+            prev_rect.moveLeft(int(prev_x))
 
             value_x = prev_x + prev_rect.width() + self._char_width
-            value_rect = QtCore.QRect(0, 0, value_size.width(), value_size.height())
-            value_rect.moveBottomLeft(QtCore.QPoint(value_x, y))
+            value_rect = QtCore.QRect(0, 0, int(value_size.width()), int(value_size.height()))
+            value_rect.moveBottomLeft(QtCore.QPoint(int(value_x), int(y)))
 
             next_x = value_x + value_size.width() + self._char_width
             next_rect.moveCenter(name_rect.center())
-            next_rect.moveLeft(next_x)
+            next_rect.moveLeft(int(next_x))
 
             # save the register shapes
             self._reg_fields[reg_name] = RegisterField(reg_name, name_rect, value_rect, arrow_rects)
@@ -274,8 +274,8 @@ def full_size(self):
         if not self.model.registers:
             return QtCore.QSize(0, 0)
 
-        width = self._reg_pos[0] + self._default_width
-        height = len(self.model.registers) * self._char_height
+        width = int(self._reg_pos[0] + self._default_width)
+        height = int(len(self.model.registers) * self._char_height)
 
         return QtCore.QSize(width, height)
 

plugins/tenet/ui/trace_view.py

@@ -479,7 +479,7 @@ def _idx2pos(self, idx):
         #assert self._cell_spacing % 2 == 0
 
         # compute the y position of the 'first' cell
-        y += self._cell_spacing / 2   # pad out from top
+        y += self._cell_spacing // 2   # pad out from top
         y += self._cell_border        # top border of cell
 
         # compute the y position of any given cell after the first
@@ -953,7 +953,7 @@ def _draw_code_cells(self, painter):
                 painter.setBrush(self.pctx.palette.trace_unmapped)
 
             y = self._idx2pos(idx)
-            painter.drawRect(x, y, w, h)
+            painter.drawRect(int(x), int(y), int(w), int(h))
 
     def _draw_highlights(self):
         """
@@ -1008,7 +1008,7 @@ def _draw_highlights_cells(self, painter):
                 y = self._idx2pos(idx) + self._cell_border
 
                 # draw cell body
-                painter.drawRect(viz_x, y, viz_w, h)
+                painter.drawRect(int(viz_x), int(y), int(viz_w), int(h))
 
     def _draw_highlights_trace(self, painter):
         """
@@ -1090,13 +1090,13 @@ def _draw_cursor(self):
             self._painter_cursor.setBrush(self.pctx.palette.trace_cursor_highlight)
 
             if draw_reader_cursor:
-                self._painter_cursor.drawRect(viz_x, cell_y, viz_w, cell_body_height)
+                self._painter_cursor.drawRect(int(viz_x), int(cell_y), int(viz_w), int(cell_body_height))
 
             # cursor hover highlighting an event
             if self._hovered_idx != INVALID_IDX:
                 hovered_y = self._idx2pos(self._hovered_idx)
                 hovered_cell_y = hovered_y + self._cell_border
-                self._painter_cursor.drawRect(viz_x, hovered_cell_y, viz_w, cell_body_height)
+                self._painter_cursor.drawRect(int(viz_x), int(hovered_cell_y), int(viz_w), int(cell_body_height))
 
         # draw the user cursor in dense/landscape mode
         else:
@@ -1172,7 +1172,7 @@ def _draw_selection(self):
         h = end_y - start_y
 
         # draw the screen door / selection rect
-        self._painter_selection.drawRect(x, y, w, h)
+        self._painter_selection.drawRect(int(x), int(y), int(w), int(h))
 
     def _draw_border(self):
         """

plugins/tenet/util/qt/waitbox.py

@@ -86,16 +86,16 @@ def _ui_layout(self):
             self._abort_button.clicked.connect(self._abort)
             v_layout.addWidget(self._abort_button)
 
-        v_layout.setSpacing(self._dpi_scale*3)
+        v_layout.setSpacing(int(self._dpi_scale*3))
         v_layout.setContentsMargins(
-            self._dpi_scale*5,
-            self._dpi_scale,
-            self._dpi_scale*5,
-            self._dpi_scale
+            int(self._dpi_scale*5),
+            int(self._dpi_scale),
+            int(self._dpi_scale*5),
+            int(self._dpi_scale)
         )
 
         # scale widget dimensions based on DPI
-        height = self._dpi_scale * 15
+        height = int(self._dpi_scale * 15)
         self.setMinimumHeight(height)
 
         # compute the dialog layout