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

angr/analyses/typehoon/typeconsts.py

@@ -42,7 +42,7 @@ class TypeConstant:
             raise NotImplementedError
         return self.SIZE
 
-    def __repr__(self, memo=None):
+    def __repr__(self, memo=None) -> str:
         raise NotImplementedError
 
 
@@ -57,7 +57,7 @@ class BottomType(TypeConstant):
 
 
 class Int(TypeConstant):
-    def __repr__(self, memo=None):
+    def __repr__(self, memo=None) -> str:
         return "intbase"
 
 
@@ -82,14 +82,14 @@ class Int16(Int):
 class Int32(Int):
     SIZE = 4
 
-    def __repr__(self, memo=None):
+    def __repr__(self, memo=None) -> str:
         return "int32"
 
 
 class Int64(Int):
     SIZE = 8
 
-    def __repr__(self, memo=None):
+    def __repr__(self, memo=None) -> str:
         return "int64"
 
 
@@ -115,7 +115,7 @@ class Int512(Int):
 
 
 class FloatBase(TypeConstant):
-    def __repr__(self, memo=None):
+    def __repr__(self, memo=None) -> str:
         return "floatbase"
 
 
@@ -185,6 +185,12 @@ class Array(TypeConstant):
         self.element: TypeConstant | None = element
         self.count: int | None = count
 
+    @property
+    def size(self) -> int:
+        if not self.count or not self.element:
+            return 0
+        return self.element.size * self.count
+
     @memoize
     def __repr__(self, memo=None):
         if self.count is None:
@@ -221,6 +227,13 @@ class Struct(TypeConstant):
         tpl = tuple((k, self.fields[k]._hash(visited) if self.fields[k] is not None else None) for k in keys)
         return hash(tpl)
 
+    @property
+    def size(self) -> int:
+        if not self.fields:
+            return 0
+        max_field_off = max(self.fields.keys())
+        return max_field_off + self.fields[max_field_off].size
+
     @memoize
     def __repr__(self, memo=None):
         prefix = "struct"

angr/analyses/variable_recovery/engine_ail.py

@@ -84,7 +84,7 @@ class SimEngineVRAIL(
                     if vvar is not None:
                         r = self._read_from_vvar(vvar, expr=stmt.src, vvar_id=self._mapped_vvarid(vvar.varid))
                         if r.variable is not None:
-                            pv = self.variable_manager[self.func_addr]._phi_variables
+                            pv = self.state.variable_manager[self.func_addr]._phi_variables
                             if variable not in pv:
                                 pv[variable] = set()
                             pv[variable].add(r.variable)

angr/analyses/variable_recovery/engine_base.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, TYPE_CHECKING, Generic, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 import contextlib
 import logging
 
@@ -16,8 +16,6 @@ from angr.code_location import CodeLocation
 from angr.analyses.typehoon import typevars, typeconsts
 from angr.analyses.typehoon.typevars import TypeVariable, DerivedTypeVariable, AddN, SubN, Load, Store
 
-if TYPE_CHECKING:
-    from angr.knowledge_plugins.variables.variable_manager import VariableManager
 
 #
 # The base engine used in VariableRecoveryFast
@@ -72,8 +70,6 @@ class SimEngineVRBase(
     and storing data.
     """
 
-    variable_manager: VariableManager
-
     def __init__(self, project, kb):
         super().__init__(project)
 
@@ -86,10 +82,6 @@ class SimEngineVRBase(
             return None
         return self.state.function.addr
 
-    def process(self, state, *args, **kwargs):
-        self.variable_manager = state.variable_manager
-        super().process(state, *args, **kwargs)
-
     def _top(self, bits):
         return RichR(self.state.top(bits))
 
@@ -130,9 +122,9 @@ class SimEngineVRBase(
                 if abs_offset.op == "__lshift__" and cast(claripy.ast.BV, abs_offset.args[1]).concrete:
                     offset = cast(claripy.ast.BV, abs_offset.args[0])
                     elem_size = 2 ** cast(claripy.ast.BV, abs_offset.args[1]).concrete_value
-                elif abs_offset.op == "__mul__" and abs_offset.args[1].concrete:
-                    offset = abs_offset.args[0]
-                    elem_size = abs_offset.args[1].concrete_value
+                elif abs_offset.op == "__mul__" and cast(claripy.ast.BV, abs_offset.args[1]).concrete:
+                    offset = cast(claripy.ast.BV, abs_offset.args[0])
+                    elem_size = cast(claripy.ast.BV, abs_offset.args[1]).concrete_value
 
             if base_addr is not None and offset is not None and elem_size is not None:
                 return base_addr, offset, elem_size
@@ -152,7 +144,7 @@ class SimEngineVRBase(
             # extract stack offset
             stack_offset: int | None = self.state.get_stack_offset(data)
 
-            variable_manager = self.variable_manager[self.func_addr]
+            variable_manager = self.state.variable_manager[self.func_addr]
             var_candidates: list[tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
                 self.block.addr, self.stmt_idx, "memory"
             )
@@ -190,10 +182,10 @@ class SimEngineVRBase(
                             stack_offset,
                             lea_size,
                             base="bp",
-                            ident=self.variable_manager[self.func_addr].next_variable_ident("stack"),
+                            ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
                             region=self.func_addr,
                         )
-                        self.variable_manager[self.func_addr].add_variable("stack", stack_offset, variable)
+                        self.state.variable_manager[self.func_addr].add_variable("stack", stack_offset, variable)
                         l.debug("Identified a new stack variable %s at %#x.", variable, self.ins_addr)
                         existing_vars.append((variable, 0))
 
@@ -212,7 +204,7 @@ class SimEngineVRBase(
             # this is probably an address for a global variable
             global_var_addr = data.concrete_value
 
-            variable_manager = self.variable_manager["global"]
+            variable_manager = self.state.variable_manager["global"]
 
             # special case for global variables: find existing variable by base address
             existing_vars = [(var, 0) for var in variable_manager.get_global_variables(global_var_addr)]
@@ -249,7 +241,7 @@ class SimEngineVRBase(
             # extract stack offset
             stack_offset: int | None = self.state.get_stack_offset(data)
 
-            variable_manager = self.variable_manager[self.func_addr]
+            variable_manager = self.state.variable_manager[self.func_addr]
             var_candidates: list[tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
                 self.block.addr,
                 self.stmt_idx,
@@ -265,7 +257,7 @@ class SimEngineVRBase(
         elif self.state.is_global_variable_address(data):
             # this is probably an address for a global variable
             global_var_addr = data.concrete_value
-            variable_manager = self.variable_manager["global"]
+            variable_manager = self.state.variable_manager["global"]
             # special case for global variables: find existing variable by base address
             existing_vars = [(var, 0) for var in variable_manager.get_global_variables(global_var_addr)]
         else:
@@ -319,9 +311,9 @@ class SimEngineVRBase(
         # handle register writes
 
         # first check if there is an existing variable for the atom at this location already
-        existing_vars: set[tuple[SimVariable, int]] = self.variable_manager[self.func_addr].find_variables_by_atom(
-            self.block.addr, self.stmt_idx, dst
-        )
+        existing_vars: set[tuple[SimVariable, int]] = self.state.variable_manager[
+            self.func_addr
+        ].find_variables_by_atom(self.block.addr, self.stmt_idx, dst)
         if not existing_vars:
             # next check if we are overwriting *part* of an existing variable that is not an input variable
             addr_and_variables = set()
@@ -334,7 +326,7 @@ class SimEngineVRBase(
                         addr_and_variables.update(self.state.extract_variables(value))
             except SimMemoryMissingError:
                 pass
-            input_vars = self.variable_manager[self.func_addr].input_variables()
+            input_vars = self.state.variable_manager[self.func_addr].input_variables()
             existing_vars = {
                 (av[1], av[0]) for av in addr_and_variables if av[1] not in input_vars and av[1].size > size
             }
@@ -343,10 +335,10 @@ class SimEngineVRBase(
             variable = SimRegisterVariable(
                 offset,
                 size,
-                ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                 region=self.func_addr,
             )
-            self.variable_manager[self.func_addr].add_variable("register", offset, variable)
+            self.state.variable_manager[self.func_addr].add_variable("register", offset, variable)
         else:
             variable, _ = next(iter(existing_vars))
 
@@ -355,7 +347,7 @@ class SimEngineVRBase(
         v = MultiValues(annotated_data)
         self.state.register_region.store(offset, v)
         # register with the variable manager
-        self.variable_manager[self.func_addr].write_to(variable, None, codeloc, atom=dst, overwrite=False)
+        self.state.variable_manager[self.func_addr].write_to(variable, None, codeloc, atom=dst, overwrite=False)
 
         if richr.typevar is not None:
             if not self.state.typevars.has_type_variable_for(variable, codeloc):
@@ -397,9 +389,9 @@ class SimEngineVRBase(
         self._reference(richr, codeloc)
 
         # first check if there is an existing variable for the atom at this location already
-        existing_vars: set[tuple[SimVariable, int]] = self.variable_manager[self.func_addr].find_variables_by_atom(
-            self.block.addr, self.stmt_idx, dst
-        )
+        existing_vars: set[tuple[SimVariable, int]] = self.state.variable_manager[
+            self.func_addr
+        ].find_variables_by_atom(self.block.addr, self.stmt_idx, dst)
         if not existing_vars:
             # next check if there is already a variable for the vvar ID
             addr_and_variables = set()
@@ -415,33 +407,34 @@ class SimEngineVRBase(
                 variable = SimRegisterVariable(
                     vvar.reg_offset,
                     vvar.size,
-                    ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                    ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                     region=self.func_addr,
                 )
-                self.variable_manager[self.func_addr].add_variable("register", vvar.reg_offset, variable)
+                self.state.variable_manager[self.func_addr].add_variable("register", vvar.reg_offset, variable)
             elif vvar.was_stack:
                 variable = SimStackVariable(
                     vvar.stack_offset,
                     vvar.size,
-                    ident=self.variable_manager[self.func_addr].next_variable_ident("stack"),
+                    ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
                     region=self.func_addr,
                 )
-                self.variable_manager[self.func_addr].add_variable("stack", vvar.stack_offset, variable)
+                self.state.variable_manager[self.func_addr].add_variable("stack", vvar.stack_offset, variable)
             elif vvar.was_parameter:
                 # FIXME: we assume all parameter vvars were registers
                 variable = SimRegisterVariable(
                     vvar.reg_offset,
                     vvar.size,
-                    ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                    ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                     region=self.func_addr,
                 )
-                self.variable_manager[self.func_addr].add_variable("register", vvar.oident, variable)
+                self.state.variable_manager[self.func_addr].add_variable("register", vvar.oident, variable)
             elif vvar.was_tmp:
                 # FIXME: we treat all tmp vvars as registers
+                assert vvar.tmp_idx is not None
                 variable = SimRegisterVariable(
                     4096 + vvar.tmp_idx,
                     vvar.size,
-                    ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                    ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                     region=self.func_addr,
                 )
             else:
@@ -452,7 +445,7 @@ class SimEngineVRBase(
         # FIXME: The offset does not have to be 0
         annotated_data = self.state.annotate_with_variables(data, [(0, variable)])
         self.vvar_region[vvar_id] = annotated_data
-        self.variable_manager[self.func_addr].write_to(variable, None, codeloc, atom=dst, overwrite=False)
+        self.state.variable_manager[self.func_addr].write_to(variable, None, codeloc, atom=dst, overwrite=False)
 
         if richr.typevar is not None:
             if not self.state.typevars.has_type_variable_for(variable, codeloc):
@@ -502,26 +495,26 @@ class SimEngineVRBase(
 
         if not stored:
             # remove existing variables linked to this statement
-            existing_vars = self.variable_manager[self.func_addr].find_variables_by_stmt(
+            existing_vars = self.state.variable_manager[self.func_addr].find_variables_by_stmt(
                 self.block.addr, self.stmt_idx, "memory"
             )
             codeloc = self._codeloc()
             if existing_vars:
                 for existing_var, _ in list(existing_vars):
-                    self.variable_manager[self.func_addr].remove_variable_by_atom(codeloc, existing_var, atom)
+                    self.state.variable_manager[self.func_addr].remove_variable_by_atom(codeloc, existing_var, atom)
 
             # storing to a location specified by a pointer whose value cannot be determined at this point
-            self._store_to_variable(richr_addr, size)
+            self._store_to_variable(richr_addr, data, size)
 
     def _store_to_stack(
         self, stack_offset, data: RichR[claripy.ast.BV | claripy.ast.FP], size, offset=0, atom=None, endness=None
     ):
         if atom is None:
-            existing_vars = self.variable_manager[self.func_addr].find_variables_by_stmt(
+            existing_vars = self.state.variable_manager[self.func_addr].find_variables_by_stmt(
                 self.block.addr, self.stmt_idx, "memory"
             )
         else:
-            existing_vars = self.variable_manager[self.func_addr].find_variables_by_atom(
+            existing_vars = self.state.variable_manager[self.func_addr].find_variables_by_atom(
                 self.block.addr, self.stmt_idx, atom
             )
         if not existing_vars:
@@ -529,12 +522,12 @@ class SimEngineVRBase(
                 stack_offset,
                 size,
                 base="bp",
-                ident=self.variable_manager[self.func_addr].next_variable_ident("stack"),
+                ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
                 region=self.func_addr,
             )
             variable_offset = offset
             if isinstance(stack_offset, int):
-                self.variable_manager[self.func_addr].set_variable("stack", stack_offset, variable)
+                self.state.variable_manager[self.func_addr].set_variable("stack", stack_offset, variable)
                 l.debug("Identified a new stack variable %s at %#x.", variable, self.ins_addr)
 
         else:
@@ -562,7 +555,7 @@ class SimEngineVRBase(
                 offset_into_var = var_offset
                 if offset_into_var == 0:
                     offset_into_var = None
-                self.variable_manager[self.func_addr].write_to(
+                self.state.variable_manager[self.func_addr].write_to(
                     var,
                     offset_into_var,
                     codeloc,
@@ -589,7 +582,7 @@ class SimEngineVRBase(
         offset: claripy.ast.BV | None = None,
         elem_size: int | None = None,
     ):
-        variable_manager = self.variable_manager["global"]
+        variable_manager = self.state.variable_manager["global"]
         if stmt is None:
             existing_vars = variable_manager.find_variables_by_stmt(self.block.addr, self.stmt_idx, "memory")
         else:
@@ -677,7 +670,7 @@ class SimEngineVRBase(
                 self.state.add_type_constraint(typevars.Subtype(store_typevar, typeconsts.TopType()))
                 self.state.add_type_constraint(typevars.Subtype(data.typevar, store_typevar))
 
-    def _store_to_variable(self, richr_addr: RichR[claripy.ast.BV], size: int):
+    def _store_to_variable(self, richr_addr: RichR[claripy.ast.BV], data: RichR, size: int):
         addr_variable = richr_addr.variable
         codeloc = self._codeloc()
 
@@ -696,13 +689,11 @@ class SimEngineVRBase(
                 base_typevar = typevar
                 field_offset = 0
 
-            # if addr_variable is not None:
-            #     self.variable_manager[self.func_addr].reference_at(addr_variable, field_offset, codeloc, atom=stmt)
-
             store_typevar = self._create_access_typevar(base_typevar, True, size, field_offset)
             if addr_variable is not None:
                 self.state.typevars.add_type_variable(addr_variable, codeloc, typevar)
-            self.state.add_type_constraint(typevars.Subtype(store_typevar, typeconsts.TopType()))
+            data_typevar = data.typevar if data.typevar is not None else typeconsts.TopType()
+            self.state.add_type_constraint(typevars.Subtype(store_typevar, data_typevar))
 
     def _load(self, richr_addr: RichR[claripy.ast.BV], size: int, expr=None):
         """
@@ -766,16 +757,18 @@ class SimEngineVRBase(
                                     all_vars.add((var_offset, var_))
 
                 if not all_vars and concrete_offset is not None:
-                    variables = self.variable_manager[self.func_addr].find_variables_by_stack_offset(concrete_offset)
+                    variables = self.state.variable_manager[self.func_addr].find_variables_by_stack_offset(
+                        concrete_offset
+                    )
                     if not variables:
                         variable = SimStackVariable(
                             concrete_offset,
                             size,
                             base="bp",
-                            ident=self.variable_manager[self.func_addr].next_variable_ident("stack"),
+                            ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
                             region=self.func_addr,
                         )
-                        self.variable_manager[self.func_addr].add_variable("stack", concrete_offset, variable)
+                        self.state.variable_manager[self.func_addr].add_variable("stack", concrete_offset, variable)
                         variables = {variable}
                         l.debug("Identified a new stack variable %s at %#x.", variable, self.ins_addr)
                     for variable in variables:
@@ -814,7 +807,7 @@ class SimEngineVRBase(
                                 var_offset,
                             ),
                         )
-                self.variable_manager[self.func_addr].read_from(
+                self.state.variable_manager[self.func_addr].read_from(
                     var,
                     offset_into_variable,
                     codeloc,
@@ -864,12 +857,12 @@ class SimEngineVRBase(
         if v is None and expr is not None:
             # failed to map the address to a known variable
             # remove existing variables linked to this variable
-            existing_vars = self.variable_manager[self.func_addr].find_variables_by_atom(
+            existing_vars = self.state.variable_manager[self.func_addr].find_variables_by_atom(
                 self.block.addr, self.stmt_idx, expr
             )
             if existing_vars:
                 for existing_var, _ in list(existing_vars):
-                    self.variable_manager[self.func_addr].remove_variable_by_atom(codeloc, existing_var, expr)
+                    self.state.variable_manager[self.func_addr].remove_variable_by_atom(codeloc, existing_var, expr)
 
         # Loading data from a pointer
         if richr_addr.type_constraints:
@@ -901,7 +894,7 @@ class SimEngineVRBase(
         offset: claripy.ast.BV | None = None,
         elem_size: int | None = None,
     ) -> RichR[claripy.ast.BV]:
-        variable_manager = self.variable_manager["global"]
+        variable_manager = self.state.variable_manager["global"]
         if expr is None:
             existing_vars = variable_manager.find_variables_by_stmt(self.block.addr, self.stmt_idx, "memory")
         else:
@@ -950,13 +943,13 @@ class SimEngineVRBase(
             # it's an array!
             if offset.concrete:
                 concrete_offset = offset.concrete_value * elem_size
-                load_typevar = self._create_access_typevar(typevar, True, size, concrete_offset)
+                load_typevar = self._create_access_typevar(typevar, False, size, concrete_offset)
                 self.state.add_type_constraint(typevars.Subtype(load_typevar, typeconsts.TopType()))
             else:
                 # FIXME: This is a hack
                 for i in range(4):
                     concrete_offset = size * i
-                    load_typevar = self._create_access_typevar(typevar, True, size, concrete_offset)
+                    load_typevar = self._create_access_typevar(typevar, False, size, concrete_offset)
                     self.state.add_type_constraint(typevars.Subtype(load_typevar, typeconsts.TopType()))
 
         return RichR(self.state.top(size * self.project.arch.byte_width), typevar=typevar)
@@ -992,11 +985,11 @@ class SimEngineVRBase(
                 variable = SimRegisterVariable(
                     offset,
                     size if force_variable_size is None else force_variable_size,
-                    ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                    ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                     region=self.func_addr,
                 )
                 value = self.state.annotate_with_variables(value, [(0, variable)])
-                self.variable_manager[self.func_addr].add_variable("register", offset, variable)
+                self.state.variable_manager[self.func_addr].add_variable("register", offset, variable)
             self.state.register_region.store(offset, value)
             value_list = [{value}]
         else:
@@ -1006,7 +999,9 @@ class SimEngineVRBase(
         for value_set in value_list:
             for value in value_set:
                 for _, var in self.state.extract_variables(value):
-                    self.variable_manager[self.func_addr].read_from(var, None, codeloc, atom=expr, overwrite=False)
+                    self.state.variable_manager[self.func_addr].read_from(
+                        var, None, codeloc, atom=expr, overwrite=False
+                    )
                     variable_set.add(var)
 
         if offset == self.project.arch.sp_offset:
@@ -1078,20 +1073,20 @@ class SimEngineVRBase(
                     variable = SimRegisterVariable(
                         vvar.reg_offset,
                         vvar.size,
-                        ident=self.variable_manager[self.func_addr].next_variable_ident("register"),
+                        ident=self.state.variable_manager[self.func_addr].next_variable_ident("register"),
                         region=self.func_addr,
                     )
                     value = self.state.annotate_with_variables(value, [(0, variable)])
-                    self.variable_manager[self.func_addr].add_variable("register", vvar.reg_offset, variable)
+                    self.state.variable_manager[self.func_addr].add_variable("register", vvar.reg_offset, variable)
                 elif vvar.category == ailment.Expr.VirtualVariableCategory.STACK:
                     variable = SimStackVariable(
                         vvar.stack_offset,
                         vvar.size,
-                        ident=self.variable_manager[self.func_addr].next_variable_ident("stack"),
+                        ident=self.state.variable_manager[self.func_addr].next_variable_ident("stack"),
                         region=self.func_addr,
                     )
                     value = self.state.annotate_with_variables(value, [(0, variable)])
-                    self.variable_manager[self.func_addr].add_variable("stack", vvar.stack_offset, variable)
+                    self.state.variable_manager[self.func_addr].add_variable("stack", vvar.stack_offset, variable)
                 elif vvar.category == ailment.Expr.VirtualVariableCategory.PARAMETER:
                     raise KeyError(f"Missing virtual variable for parameter {vvar}")
                 elif vvar.category == ailment.Expr.VirtualVariableCategory.TMP:
@@ -1104,7 +1099,7 @@ class SimEngineVRBase(
 
         variable_set = set()
         for _, var in self.state.extract_variables(value):
-            self.variable_manager[self.func_addr].read_from(var, None, codeloc, atom=expr, overwrite=False)
+            self.state.variable_manager[self.func_addr].read_from(var, None, codeloc, atom=expr, overwrite=False)
             variable_set.add(var)
 
         if (

angr/analyses/variable_recovery/engine_vex.py

@@ -51,7 +51,7 @@ class SimEngineVRVEX(
 
     def _process_block(self, whitelist=None):
         scanner = VEXIRSBScanner(self.project, logger=self.l)
-        scanner._process(None, block=self.block)
+        scanner.process(None, block=self.block)
         self.stmts_to_lower = scanner.stmts_to_lower
         self.reg_read_stmts_to_ignore = scanner.reg_read_stmts_to_ignore
 

angr/analyses/variable_recovery/irsb_scanner.py

@@ -39,12 +39,12 @@ class VEXIRSBScanner(SimEngineLightVEX[None, None, None, None]):
     def _is_top(self, expr) -> bool:
         return True
 
-    def _process(self, state, *, block=None, whitelist=None, **kwargs):
+    def process(self, state, *, block=None, whitelist=None, **kwargs):
         self.tmps_with_64bit_regs = set()
         self.tmps_assignment_stmtidx = {}
         self.tmps_converted_to_32bit = set()
 
-        super()._process(state, block=block, whitelist=whitelist, **kwargs)
+        super().process(state, block=block, whitelist=whitelist, **kwargs)
 
         self.stmts_to_lower = {self.tmps_assignment_stmtidx[i] for i in self.tmps_converted_to_32bit}