angr 9.2.131__py3-none-manylinux2014_x86_64.whl → 9.2.132__py3-none-manylinux2014_x86_64.whl

angr/block.py

@@ -13,12 +13,9 @@ except ImportError:
 
 from .protos import primitives_pb2 as pb2
 from .serializable import Serializable
-from .engines.vex import VEXLifter
 
 l = logging.getLogger(name=__name__)
 
-DEFAULT_VEX_ENGINE = VEXLifter(None)  # this is only used when Block is not initialized with a project
-
 
 class DisassemblerBlock:
     """
@@ -38,7 +35,7 @@ class DisassemblerBlock:
         print(str(self))
 
     def __str__(self):
-        return "\n".join(map(str, self.insns))
+        return "\n".join(str(x) for x in self.insns)
 
     def __repr__(self):
         return f"<DisassemblerBlock for {self.addr:#x}>"
@@ -326,8 +323,6 @@ class Block(Serializable):
 
     @property
     def _vex_engine(self):
-        if self._project is None:
-            return DEFAULT_VEX_ENGINE
         return self._project.factory.default_engine
 
     @property
@@ -436,7 +431,7 @@ class Block(Serializable):
         return self._bytes
 
     @property
-    def instructions(self):
+    def instructions(self) -> int:
         if not self._instructions and self._vex is None:
             # initialize from VEX
             _ = self.vex
@@ -457,7 +452,7 @@ class Block(Serializable):
 
     @classmethod
     def _get_cmsg(cls):
-        return pb2.Block()
+        return pb2.Block()  # pylint: disable=no-member
 
     def serialize_to_cmessage(self):
         obj = self._get_cmsg()
@@ -490,7 +485,7 @@ class SootBlock:
     @property
     def _soot_engine(self):
         if self._project is None:
-            raise Exception("SHIIIIIIIT")
+            assert False, "This should be unreachable"
         return self._project.factory.default_engine
 
     @property

angr/calling_conventions.py

@@ -229,7 +229,7 @@ class SimFunctionArgument:
     :ivar bool is_fp:  Whether loads from this location should return a floating point bitvector
     """
 
-    def __init__(self, size, is_fp=False):
+    def __init__(self, size: int, is_fp: bool = False):
         self.size = size
         self.is_fp = is_fp
 

angr/engines/engine.py

@@ -1,33 +1,44 @@
-# pylint: disable=no-self-use,unused-private-member
 from __future__ import annotations
 
+from typing import Generic, TypeVar
 import abc
 import logging
 import threading
 
+
 from archinfo.arch_soot import SootAddressDescriptor
+import claripy
 
 import angr
+from angr.sim_state import SimState
 from angr import sim_options as o
 from angr.errors import SimException
 from angr.state_plugins.inspect import BP_AFTER, BP_BEFORE
-
 from .successors import SimSuccessors
 
+
 l = logging.getLogger(name=__name__)
 
 
-class SimEngineBase:
+StateType = TypeVar("StateType")
+ResultType = TypeVar("ResultType")
+DataType_co = TypeVar("DataType_co", covariant=True)
+HeavyState = SimState[int | SootAddressDescriptor, claripy.ast.BV | SootAddressDescriptor]
+
+
+class SimEngineBase(Generic[StateType]):
     """
     Even more basey of a base class for SimEngine. Used as a base by mixins which want access to the project but for
     which having method `process` (contained in `SimEngine`) doesn't make sense
     """
 
-    def __init__(self, project=None, **kwargs):
+    state: StateType
+
+    def __init__(self, project: angr.Project, **kwargs):
         if kwargs:
             raise TypeError("Unused initializer args: " + ", ".join(kwargs.keys()))
-        self.project: angr.Project | None = project
-        self.state = None
+        self.project = project
+        self.arch = self.project.arch
 
     __tls = ("state",)
 
@@ -36,16 +47,15 @@ class SimEngineBase:
 
     def __setstate__(self, state):
         self.project = state[0]
-        self.state = None
 
 
-class SimEngine(SimEngineBase, metaclass=abc.ABCMeta):
+class SimEngine(Generic[StateType, ResultType], SimEngineBase[StateType], metaclass=abc.ABCMeta):
     """
     A SimEngine is a class which understands how to perform execution on a state. This is a base class.
     """
 
     @abc.abstractmethod
-    def process(self, state, **kwargs):
+    def process(self, state: StateType, **kwargs) -> ResultType:
         """
         The main entry point for an engine. Should take a state and return a result.
 
@@ -62,6 +72,8 @@ class TLSMixin:
     MAGIC MAGIC MAGIC
     """
 
+    __local: threading.local  # pylint: disable=unused-private-member
+
     def __new__(cls, *args, **kwargs):  # pylint:disable=unused-argument
         obj = super().__new__(cls)
         obj.__local = threading.local()
@@ -76,8 +88,9 @@ class TLSMixin:
                     attr = f"_{subcls.__name__}{attr}"
 
                 if hasattr(cls, attr):
-                    if type(getattr(cls, attr, None)) is not TLSProperty:
-                        raise Exception(f"Programming error: {attr} is both in __tls and __class__")
+                    assert (
+                        type(getattr(cls, attr, None)) is TLSProperty
+                    ), f"Programming error: {attr} is both in __tls and __class__"
                 else:
                     setattr(cls, attr, TLSProperty(attr))
 
@@ -98,7 +111,7 @@ class TLSProperty:  # pylint:disable=missing-class-docstring
         delattr(instance._TLSMixin__local, self.name)
 
 
-class SuccessorsMixin(SimEngine):
+class SuccessorsMixin(SimEngine[HeavyState, SimSuccessors]):
     """
     A mixin for SimEngine which implements ``process`` to perform common operations related to symbolic execution
     and dispatches to a ``process_successors`` method to fill a SimSuccessors object with the results.
@@ -111,7 +124,7 @@ class SuccessorsMixin(SimEngine):
 
     __tls = ("successors",)
 
-    def process(self, state, *args, **kwargs):  # pylint:disable=unused-argument
+    def process(self, state: HeavyState, **kwargs) -> SimSuccessors:  # pylint:disable=unused-argument
         """
         Perform execution with a state.
 
@@ -148,6 +161,7 @@ class SuccessorsMixin(SimEngine):
         new_state.register_plugin("history", old_state.history.make_child())
         new_state.history.recent_bbl_addrs.append(addr)
         if new_state.arch.unicorn_support:
+            assert isinstance(addr, int)
             new_state.scratch.executed_pages_set = {addr & ~0xFFF}
 
         self.successors = SimSuccessors(addr, old_state)
@@ -161,10 +175,12 @@ class SuccessorsMixin(SimEngine):
         except SimException as e:
             if o.EXCEPTION_HANDLING not in old_state.options:
                 raise
+            assert old_state.project is not None
             old_state.project.simos.handle_exception(self.successors, self, e)
 
         new_state._inspect("engine_process", when=BP_AFTER, sim_successors=self.successors, address=addr)
         self.successors = new_state._inspect_getattr("sim_successors", self.successors)
+        assert self.successors is not None
 
         # downsizing
         if new_state.supports_inspect:
@@ -183,7 +199,7 @@ class SuccessorsMixin(SimEngine):
 
         return self.successors
 
-    def process_successors(self, successors, **kwargs):  # pylint:disable=unused-argument
+    def process_successors(self, successors, **kwargs):  # pylint:disable=unused-argument,no-self-use
         """
         Implement this function to fill out the SimSuccessors object with the results of stepping state.
 

angr/engines/light/__init__.py

@@ -1,15 +1,23 @@
 from __future__ import annotations
 
 from .data import ArithmeticExpression, SpOffset, RegisterOffset
-from .engine import SimEngineLight, SimEngineLightVEXMixin, SimEngineLightAILMixin, SimEngineLightVEX, SimEngineLightAIL
+from .engine import (
+    SimEngineLight,
+    SimEngineLightVEX,
+    SimEngineLightAIL,
+    SimEngineNostmtVEX,
+    SimEngineNostmtAIL,
+    SimEngineNoexprAIL,
+)
 
 __all__ = (
     "ArithmeticExpression",
     "SpOffset",
     "RegisterOffset",
     "SimEngineLight",
-    "SimEngineLightVEXMixin",
-    "SimEngineLightAILMixin",
     "SimEngineLightVEX",
     "SimEngineLightAIL",
+    "SimEngineNostmtVEX",
+    "SimEngineNostmtAIL",
+    "SimEngineNoexprAIL",
 )