angr 9.2.135__py3-none-manylinux2014_aarch64.whl → 9.2.137__py3-none-manylinux2014_aarch64.whl

angr/block.py

@@ -1,18 +1,26 @@
 # pylint:disable=wrong-import-position,arguments-differ
 from __future__ import annotations
 import logging
+from typing import TYPE_CHECKING
 
 import pyvex
 from pyvex import IRSB
-from archinfo import ArchARM
+from archinfo import Arch, ArchARM
+
+from .protos import primitives_pb2 as pb2
+from .serializable import Serializable
 
 try:
     from .engines import pcode
 except ImportError:
     pcode = None
 
-from .protos import primitives_pb2 as pb2
-from .serializable import Serializable
+if TYPE_CHECKING:
+    from angr import Project
+    from angr.engines.vex import VEXLifter
+    from angr.engines.pcode.lifter import PcodeLifterEngineMixin, IRSB as PcodeIRSB
+    from angr.engines.soot.engine import SootMixin
+
 
 l = logging.getLogger(name=__name__)
 
@@ -147,7 +155,7 @@ class Block(Serializable):
         self,
         addr,
         project=None,
-        arch=None,
+        arch: Arch = None,
         size=None,
         max_size=None,
         byte_string=None,
@@ -167,6 +175,7 @@ class Block(Serializable):
         skip_stmts=False,
     ):
         # set up arch
+        self.arch: Arch
         if project is not None:
             self.arch = project.arch
         else:
@@ -186,7 +195,7 @@ class Block(Serializable):
         else:
             thumb = False
 
-        self._project = project
+        self._project: Project | None = project
         self.thumb = thumb
         self.addr = addr
         self._opt_level = opt_level
@@ -205,8 +214,15 @@ class Block(Serializable):
             else:
                 if self._initial_regs:
                     self.set_initial_regs()
+                clemory = None
+                if project is not None:
+                    clemory = (
+                        project.loader.memory_ro_view
+                        if project.loader.memory_ro_view is not None
+                        else project.loader.memory
+                    )
                 vex = self._vex_engine.lift_vex(
-                    clemory=project.loader.memory,
+                    clemory=clemory,
                     state=backup_state,
                     insn_bytes=byte_string,
                     addr=addr,
@@ -242,7 +258,7 @@ class Block(Serializable):
         self._load_from_ro_regions = load_from_ro_regions
         self._const_prop = const_prop
 
-        self._instructions = num_inst
+        self._instructions: int | None = num_inst
         self._instruction_addrs: list[int] = []
 
         if skip_stmts:
@@ -257,7 +273,7 @@ class Block(Serializable):
                 if type(self._bytes) is memoryview:
                     self._bytes = bytes(self._bytes)
                 elif type(self._bytes) is not bytes:
-                    self._bytes = bytes(pyvex.ffi.buffer(self._bytes, size))
+                    self._bytes = bytes(pyvex.ffi.buffer(self._bytes, size))  # type:ignore
             else:
                 self._bytes = None
         elif type(byte_string) is bytes:
@@ -268,7 +284,7 @@ class Block(Serializable):
         else:
             # Convert bytestring to a str
             # size will ALWAYS be known at this point
-            self._bytes = str(pyvex.ffi.buffer(byte_string, self.size))
+            self._bytes = bytes(pyvex.ffi.buffer(byte_string, self.size))  # type:ignore
 
     def _parse_vex_info(self, vex_block):
         if vex_block is not None:
@@ -322,16 +338,25 @@ class Block(Serializable):
         pyvex.pvc.reset_initial_register_values()
 
     @property
-    def _vex_engine(self):
-        return self._project.factory.default_engine
+    def _vex_engine(self) -> VEXLifter | PcodeLifterEngineMixin:
+        if self._project is None:
+            raise ValueError("Project is not set")
+        return self._project.factory.default_engine  # type:ignore
 
     @property
-    def vex(self) -> IRSB:
+    def vex(self) -> IRSB | PcodeIRSB:
         if not self._vex:
             if self._initial_regs:
                 self.set_initial_regs()
+            clemory = None
+            if self._project is not None:
+                clemory = (
+                    self._project.loader.memory_ro_view
+                    if self._project.loader.memory_ro_view is not None
+                    else self._project.loader.memory
+                )
             self._vex = self._vex_engine.lift_vex(
-                clemory=self._project.loader.memory if self._project is not None else None,
+                clemory=clemory,
                 insn_bytes=self._bytes,
                 addr=self.addr,
                 thumb=self.thumb,
@@ -349,6 +374,7 @@ class Block(Serializable):
                 self.reset_initial_regs()
             self._parse_vex_info(self._vex)
 
+        assert self._vex is not None
         return self._vex
 
     @property
@@ -361,8 +387,15 @@ class Block(Serializable):
 
         if self._initial_regs:
             self.set_initial_regs()
+        clemory = None
+        if self._project is not None:
+            clemory = (
+                self._project.loader.memory_ro_view
+                if self._project.loader.memory_ro_view is not None
+                else self._project.loader.memory
+            )
         self._vex_nostmt = self._vex_engine.lift_vex(
-            clemory=self._project.loader.memory if self._project is not None else None,
+            clemory=clemory,
             insn_bytes=self._bytes,
             addr=self.addr,
             thumb=self.thumb,
@@ -393,17 +426,17 @@ class Block(Serializable):
         """
         if self._disassembly is None:
             if self._using_pcode_engine:
-                self._disassembly = self.vex.disassembly
+                self._disassembly = self.vex.disassembly  # type:ignore
             else:
                 self._disassembly = self.capstone
         return self._disassembly
 
     @property
-    def capstone(self):
+    def capstone(self) -> CapstoneBlock:
         if self._capstone:
             return self._capstone
 
-        cs = self.arch.capstone if not self.thumb else self.arch.capstone_thumb
+        cs = self.arch.capstone if not self.thumb else self.arch.capstone_thumb  # type:ignore
 
         insns = []
 
@@ -422,12 +455,18 @@ class Block(Serializable):
         return BlockNode(self.addr, self.size, bytestr=self.bytes, thumb=self.thumb)
 
     @property
-    def bytes(self) -> bytes:
+    def bytes(self) -> bytes | None:
         if self._bytes is None:
             addr = self.addr
             if self.thumb:
                 addr = (addr >> 1) << 1
-            self._bytes = self._project.loader.memory.load(addr, self.size)
+            if self._project is not None:
+                mem = (
+                    self._project.loader.memory_ro_view
+                    if self._project.loader.memory_ro_view is not None
+                    else self._project.loader.memory
+                )
+                self._bytes = mem.load(addr, self.size)
         return self._bytes
 
     @property
@@ -436,6 +475,7 @@ class Block(Serializable):
             # initialize from VEX
             _ = self.vex
 
+        assert self._instructions is not None
         return self._instructions
 
     @property
@@ -476,17 +516,17 @@ class SootBlock:
     Represents a Soot IR basic block.
     """
 
-    def __init__(self, addr, project=None, arch=None):
+    def __init__(self, addr, *, project: Project, arch: Arch):
         self.addr = addr
         self.arch = arch
         self._project = project
         self._the_binary = project.loader.main_object
 
     @property
-    def _soot_engine(self):
+    def _soot_engine(self) -> SootMixin:
         if self._project is None:
             assert False, "This should be unreachable"
-        return self._project.factory.default_engine
+        return self._project.factory.default_engine  # type:ignore
 
     @property
     def soot(self):

angr/callable.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import pycparser
 
+from .errors import AngrCallableError, AngrCallableMultistateError
 from .calling_conventions import default_cc, SimCC
 
 
@@ -158,6 +159,3 @@ class Callable:
                 raise AngrCallableError(f"Unsupported expression type {type(expr)}.")
 
         return self.__call__(*args)
-
-
-from .errors import AngrCallableError, AngrCallableMultistateError

angr/calling_conventions.py

@@ -1600,7 +1600,7 @@ class SimCCSystemVAMD64(SimCC):
                     # TODO I think we need an explicit stride field on array types
                     result[idx * ty.elem_type.size // self.arch.byte_width + suboffset] += subsubty_list
         elif isinstance(ty, SimUnion):
-            for field, subty in ty.members.items():
+            for subty in ty.members.values():
                 subresult = self._flatten(subty)
                 if subresult is None:
                     return None
@@ -1772,7 +1772,7 @@ class SimCCARM(SimCC):
                     # TODO I think we need an explicit stride field on array types
                     result[idx * ty.elem_type.size // self.arch.byte_width + suboffset] += subsubty_list
         elif isinstance(ty, SimUnion):
-            for field, subty in ty.members.items():
+            for subty in ty.members.values():
                 subresult = self._flatten(subty)
                 if subresult is None:
                     return None
@@ -1991,7 +1991,7 @@ class SimCCO32(SimCC):
                     # TODO I think we need an explicit stride field on array types
                     result[idx * ty.elem_type.size // self.arch.byte_width + suboffset] += subsubty_list
         elif isinstance(ty, SimUnion):
-            for field, subty in ty.members.items():
+            for subty in ty.members.values():
                 subresult = self._flatten(subty)
                 if subresult is None:
                     return None

angr/codenode.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import logging
+import weakref
 
 l = logging.getLogger(name=__name__)
 
@@ -17,7 +18,7 @@ class CodeNode:
         self.addr: int = addr
         self.size: int = size
         self.thumb = thumb
-        self._graph = graph
+        self._graph = weakref.proxy(graph) if graph is not None else None
 
         self._hash = None
 
@@ -46,6 +47,9 @@ class CodeNode:
             self._hash = hash((self.addr, self.size))
         return self._hash
 
+    def set_graph(self, graph):
+        self._graph = weakref.proxy(graph)
+
     def successors(self) -> list[CodeNode]:
         if self._graph is None:
             raise ValueError("Cannot calculate successors for graphless node")

angr/concretization_strategies/__init__.py

@@ -1,89 +1,7 @@
 from __future__ import annotations
 
-
-class SimConcretizationStrategy:
-    """
-    Concretization strategies control the resolution of symbolic memory indices
-    in SimuVEX. By subclassing this class and setting it as a concretization strategy
-    (on state.memory.read_strategies and state.memory.write_strategies), SimuVEX's
-    memory index concretization behavior can be modified.
-    """
-
-    def __init__(self, filter=None, exact=True):  # pylint:disable=redefined-builtin
-        """
-        Initializes the base SimConcretizationStrategy.
-
-        :param filter: A function, taking arguments of (SimMemory, claripy.AST) that determines
-                       if this strategy can handle resolving the provided AST.
-        :param exact: A flag (default: True) that determines if the convenience resolution
-                      functions provided by this class use exact or approximate resolution.
-        """
-        self._exact = exact
-        self._filter = filter
-
-    def _min(self, memory, addr, **kwargs):
-        """
-        Gets the minimum solution of an address.
-        """
-        return memory.state.solver.min(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
-
-    def _max(self, memory, addr, **kwargs):
-        """
-        Gets the maximum solution of an address.
-        """
-        return memory.state.solver.max(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
-
-    def _any(self, memory, addr, **kwargs):
-        """
-        Gets any solution of an address.
-        """
-        return memory.state.solver.eval(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
-
-    def _eval(self, memory, addr, n, **kwargs):
-        """
-        Gets n solutions for an address.
-        """
-        return memory.state.solver.eval_upto(addr, n, exact=kwargs.pop("exact", self._exact), **kwargs)
-
-    def _range(self, memory, addr, **kwargs):
-        """
-        Gets the (min, max) range of solutions for an address.
-        """
-        return (self._min(memory, addr, **kwargs), self._max(memory, addr, **kwargs))
-
-    def concretize(self, memory, addr, **kwargs):
-        """
-        Concretizes the address into a list of values.
-        If this strategy cannot handle this address, returns None.
-        """
-        if self._filter is None or self._filter(memory, addr):
-            return self._concretize(memory, addr, **kwargs)
-        return None
-
-    def _concretize(self, memory, addr, **kwargs):
-        """
-        Should be implemented by child classes to handle concretization.
-        :param **kwargs:
-        """
-        raise NotImplementedError
-
-    def copy(self):
-        """
-        Returns a copy of the strategy, if there is data that should be kept separate between
-        states. If not, returns self.
-        """
-        return self
-
-    def merge(self, others):
-        """
-        Merges this strategy with others (if there is data that should be kept separate between
-        states. If not, is a no-op.
-        """
-
-
-# pylint: disable=wrong-import-position
-# FIXME: This is a circular import, move base class to a separate file
 from .any import SimConcretizationStrategyAny
+from .base import SimConcretizationStrategy
 from .controlled_data import SimConcretizationStrategyControlledData
 from .eval import SimConcretizationStrategyEval
 from .max import SimConcretizationStrategyMax

angr/concretization_strategies/any.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyAny(SimConcretizationStrategy):

angr/concretization_strategies/any_named.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import claripy
 
-from . import SimConcretizationStrategy
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyAnyNamed(SimConcretizationStrategy):

angr/concretization_strategies/base.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+
+class SimConcretizationStrategy:
+    """
+    Concretization strategies control the resolution of symbolic memory indices
+    in SimuVEX. By subclassing this class and setting it as a concretization strategy
+    (on state.memory.read_strategies and state.memory.write_strategies), SimuVEX's
+    memory index concretization behavior can be modified.
+    """
+
+    def __init__(self, filter=None, exact=True):  # pylint:disable=redefined-builtin
+        """
+        Initializes the base SimConcretizationStrategy.
+
+        :param filter: A function, taking arguments of (SimMemory, claripy.AST) that determines
+                       if this strategy can handle resolving the provided AST.
+        :param exact: A flag (default: True) that determines if the convenience resolution
+                      functions provided by this class use exact or approximate resolution.
+        """
+        self._exact = exact
+        self._filter = filter
+
+    def _min(self, memory, addr, **kwargs):
+        """
+        Gets the minimum solution of an address.
+        """
+        return memory.state.solver.min(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
+
+    def _max(self, memory, addr, **kwargs):
+        """
+        Gets the maximum solution of an address.
+        """
+        return memory.state.solver.max(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
+
+    def _any(self, memory, addr, **kwargs):
+        """
+        Gets any solution of an address.
+        """
+        return memory.state.solver.eval(addr, exact=kwargs.pop("exact", self._exact), **kwargs)
+
+    def _eval(self, memory, addr, n, **kwargs):
+        """
+        Gets n solutions for an address.
+        """
+        return memory.state.solver.eval_upto(addr, n, exact=kwargs.pop("exact", self._exact), **kwargs)
+
+    def _range(self, memory, addr, **kwargs):
+        """
+        Gets the (min, max) range of solutions for an address.
+        """
+        return (self._min(memory, addr, **kwargs), self._max(memory, addr, **kwargs))
+
+    def concretize(self, memory, addr, **kwargs):
+        """
+        Concretizes the address into a list of values.
+        If this strategy cannot handle this address, returns None.
+        """
+        if self._filter is None or self._filter(memory, addr):
+            return self._concretize(memory, addr, **kwargs)
+        return None
+
+    def _concretize(self, memory, addr, **kwargs):
+        """
+        Should be implemented by child classes to handle concretization.
+        :param **kwargs:
+        """
+        raise NotImplementedError
+
+    def copy(self):
+        """
+        Returns a copy of the strategy, if there is data that should be kept separate between
+        states. If not, returns self.
+        """
+        return self
+
+    def merge(self, others):
+        """
+        Merges this strategy with others (if there is data that should be kept separate between
+        states. If not, is a no-op.
+        """

angr/concretization_strategies/controlled_data.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
+
 from itertools import groupby
 
 import claripy
 
-from . import SimConcretizationStrategy
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyControlledData(SimConcretizationStrategy):

angr/concretization_strategies/eval.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyEval(SimConcretizationStrategy):

angr/concretization_strategies/logging.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+
 import logging
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyLogging(SimConcretizationStrategy):

angr/concretization_strategies/max.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
+
 from angr.errors import SimSolverError
-from . import SimConcretizationStrategy
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyMax(SimConcretizationStrategy):

angr/concretization_strategies/nonzero.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyNonzero(SimConcretizationStrategy):

angr/concretization_strategies/nonzero_range.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyNonzeroRange(SimConcretizationStrategy):

angr/concretization_strategies/norepeats.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+
 import itertools
 
-from . import SimConcretizationStrategy
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyNorepeats(SimConcretizationStrategy):

angr/concretization_strategies/norepeats_range.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
 from angr.errors import SimMergeError
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyNorepeatsRange(SimConcretizationStrategy):

angr/concretization_strategies/range.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyRange(SimConcretizationStrategy):

angr/concretization_strategies/signed_add.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+
 import claripy
 
-from . import SimConcretizationStrategy
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategySignedAdd(SimConcretizationStrategy):

angr/concretization_strategies/single.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategySingle(SimConcretizationStrategy):

angr/concretization_strategies/solutions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategySolutions(SimConcretizationStrategy):

angr/concretization_strategies/unlimited_range.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import SimConcretizationStrategy
+
+from .base import SimConcretizationStrategy
 
 
 class SimConcretizationStrategyUnlimitedRange(SimConcretizationStrategy):

angr/engines/__init__.py

@@ -8,13 +8,10 @@ from .procedure import ProcedureMixin, ProcedureEngine
 from .unicorn import SimEngineUnicorn
 from .failure import SimEngineFailure
 from .syscall import SimEngineSyscall
-from .concrete import SimEngineConcrete
 from .hook import HooksMixin
 from .soot import SootMixin
 
 
-# The default execution engine
-# You may remove unused mixins from this default engine to speed up execution
 class UberEngine(
     SimEngineFailure,
     SimEngineSyscall,
@@ -27,7 +24,14 @@ class UberEngine(
     SootMixin,
     HeavyVEXMixin,
 ):
-    pass
+    """
+    The default execution engine for angr. This engine includes mixins for most
+    common functionality in angr, including VEX IR, unicorn, syscall handling,
+    and simprocedure handling.
+
+    For some performance-sensitive applications, you may want to create a custom
+    engine with only the necessary mixins.
+    """
 
 
 __all__ = [
@@ -37,7 +41,6 @@ __all__ = [
     "ProcedureEngine",
     "ProcedureMixin",
     "SimEngine",
-    "SimEngineConcrete",
     "SimEngineFailure",
     "SimEngineSyscall",
     "SimEngineUnicorn",

angr/engines/engine.py

@@ -32,9 +32,7 @@ class SimEngineBase(Generic[StateType]):
 
     state: StateType
 
-    def __init__(self, project: angr.Project, **kwargs):
-        if kwargs:
-            raise TypeError("Unused initializer args: " + ", ".join(kwargs.keys()))
+    def __init__(self, project: angr.Project):
         self.project = project
         self.arch = self.project.arch
 
@@ -66,8 +64,8 @@ class SuccessorsMixin(SimEngine[HeavyState, SimSuccessors]):
     and dispatches to a ``process_successors`` method to fill a SimSuccessors object with the results.
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    def __init__(self, project: angr.Project):
+        super().__init__(project)
 
         self.successors: SimSuccessors | None = None