angr 9.2.140__py3-none-manylinux2014_x86_64.whl → 9.2.142__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/ssailification/ssailification.py

@@ -79,7 +79,7 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
         # calculate virtual variables and phi nodes
         self._udef_to_phiid: dict[tuple, set[int]] = None
         self._phiid_to_loc: dict[int, tuple[int, int | None]] = None
-        self._stackvar_locs: dict[int, int] = None
+        self._stackvar_locs: dict[int, set[int]] = None
         self._calculate_virtual_variables(ail_graph, traversal.def_to_loc, traversal.loc_to_defs)
 
         # insert phi variables and rewrite uses
@@ -97,6 +97,7 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
             self._func_args,
             vvar_id_start=vvar_id_start,
         )
+        self.secondary_stackvars = rewriter.secondary_stackvars
         self.out_graph = rewriter.out_graph
         self.max_vvar_id = rewriter.max_vvar_id
 
@@ -130,7 +131,7 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
             if self._func_args:
                 for func_arg in self._func_args:
                     if func_arg.oident[0] == VirtualVariableCategory.STACK:
-                        stackvar_locs[func_arg.oident[1]] = func_arg.size
+                        stackvar_locs[func_arg.oident[1]] = {func_arg.size}
             sorted_stackvar_offs = sorted(stackvar_locs)
         else:
             stackvar_locs = {}
@@ -157,8 +158,13 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
                         off = sorted_stackvar_offs[i]
                         if off >= def_.addr.offset + def_.size:
                             break
-                        udef_to_defs[("stack", off, stackvar_locs[off])].add(def_)
-                        udef_to_blockkeys[("stack", off, stackvar_locs[off])].add((loc.block_addr, loc.block_idx))
+                        full_sz = max(stackvar_locs[off])
+                        udef_to_defs[("stack", off, full_sz)].add(def_)
+                        udef_to_blockkeys[("stack", off, full_sz)].add((loc.block_addr, loc.block_idx))
+                        # add a definition for the partial stack variable
+                        if def_.size in stackvar_locs[off] and def_.size < full_sz:
+                            udef_to_defs[("stack", off, def_.size)].add(def_)
+                            udef_to_blockkeys[("stack", off, def_.size)].add((loc.block_addr, loc.block_idx))
             elif isinstance(def_, Tmp):
                 # Tmps are local to each block and do not need phi nodes
                 pass
@@ -197,7 +203,15 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
         return last_frontier
 
     @staticmethod
-    def _synthesize_stackvar_locs(defs: list[Store]) -> dict[int, int]:
+    def _synthesize_stackvar_locs(defs: list[Store]) -> dict[int, set[int]]:
+        """
+        Derive potential locations (in terms of offsets and sizes) for stack variables based on all stack variable
+        definitions provided.
+
+        :param defs:    Store definitions.
+        :return:        A dictionary of stack variable offsets and their sizes.
+        """
+
         accesses: defaultdict[int, set[int]] = defaultdict(set)
         offs: set[int] = set()
 
@@ -208,7 +222,7 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
                 offs.add(stack_off)
 
         sorted_offs = sorted(offs)
-        locs: dict[int, int] = {}
+        locs: dict[int, set[int]] = {}
         for idx, off in enumerate(sorted_offs):
             sorted_sizes = sorted(accesses[off])
             if idx < len(sorted_offs) - 1:
@@ -217,14 +231,8 @@ class Ssailification(Analysis):  # pylint:disable=abstract-method
             else:
                 allowed_sizes = sorted_sizes
 
-            if len(allowed_sizes) == 1:
-                locs[off] = allowed_sizes[0]
-            # else:
-            #     last_off = off
-            #     for a in allowed_sizes:
-            #         locs[off + a] = off + a - last_off
-            #         last_off = off + a
-            # TODO: Update locs for sizes beyond allowed_sizes
+            if allowed_sizes:
+                locs[off] = set(allowed_sizes)
 
         return locs
 

angr/analyses/decompiler/stack_item.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class StackItemType(Enum):
+    """
+    Enum for the type of stack items.
+    """
+
+    UNKNOWN = 0
+    SAVED_BP = 1
+    SAVED_REGS = 2
+    ARGUMENT = 3
+    RET_ADDR = 4
+    STACK_CANARY = 5
+
+
+class StackItem:
+    """
+    A stack item describes a piece of data that is stored on the stack at a certain offset (usually negative).
+    """
+
+    offset: int
+    size: int
+    name: str
+    item_type: StackItemType
+
+    def __init__(self, offset: int, size: int, name: str, item_type: StackItemType = StackItemType.UNKNOWN):
+        self.offset = offset
+        self.size = size
+        self.name = name
+        self.item_type = item_type
+
+    def __repr__(self):
+        return f"<StackItem {self.name} {self.item_type!s} at {self.offset:#x} ({self.size}b)>"