angr 9.2.132__py3-none-macosx_11_0_arm64.whl → 9.2.133__py3-none-macosx_11_0_arm64.whl

angr/engines/vex/claripy/ccall.py

@@ -1701,7 +1701,7 @@ def armg_calculate_condition(state, cond_n_op, cc_dep1, cc_dep2, cc_dep3):
         return flag
 
     l.error("Unrecognized condition %d in armg_calculate_condition", concrete_cond)
-    raise SimCCallError("Unrecognized condition %d in armg_calculate_condition" % concrete_cond)
+    raise SimCCallError(f"Unrecognized condition {concrete_cond} in armg_calculate_condition")
 
 
 ARM64G_CC_SHIFT_N = 31
@@ -1991,7 +1991,7 @@ def arm64g_calculate_condition(state, cond_n_op, cc_dep1, cc_dep2, cc_dep3):
         return flag
 
     l.error("Unrecognized condition %d in arm64g_calculate_condition", concrete_cond)
-    raise SimCCallError("Unrecognized condition %d in arm64g_calculate_condition" % concrete_cond)
+    raise SimCCallError(f"Unrecognized condition {concrete_cond} in arm64g_calculate_condition")
 
 
 #

angr/engines/vex/claripy/irop.py

@@ -134,7 +134,7 @@ for _vec_lanewidth in (8, 16, 32, 64):
             continue
 
         # the regex thinks the I is an integral descriptor
-        explicit_attrs["Iop_InterleaveHI%dx%d" % (_vec_lanewidth, _vec_count)] = {
+        explicit_attrs[f"Iop_InterleaveHI{_vec_lanewidth}x{_vec_count}"] = {
             "generic_name": "InterleaveHI",
             "to_size": _vec_width,
             "vector_size": _vec_lanewidth,
@@ -220,29 +220,29 @@ class SimIROp:
     """
 
     __slots__ = (
-        "name",
-        "op_attrs",
-        "_generic_name",
-        "_from_size",
+        "_calculate",
+        "_conversion",
+        "_float",
         "_from_side",
-        "_from_type",
         "_from_signed",
-        "_to_size",
-        "_to_type",
-        "_to_signed",
+        "_from_size",
+        "_from_type",
+        "_generic_name",
+        "_output_size_bits",
+        "_output_type",
+        "_rounding_mode",
         "_set_side",
         "_set_size",
-        "_conversion",
-        "_vector_size",
+        "_to_signed",
+        "_to_size",
+        "_to_type",
+        "_vector_count",
         "_vector_signed",
+        "_vector_size",
         "_vector_type",
         "_vector_zero",
-        "_vector_count",
-        "_rounding_mode",
-        "_output_type",
-        "_output_size_bits",
-        "_float",
-        "_calculate",
+        "name",
+        "op_attrs",
     )
 
     def __init__(self, name, **attrs):
@@ -567,7 +567,7 @@ class SimIROp:
         """
         arg_num = len(args)
         if arg_num != 1:
-            raise SimOperationError("expect exactly one vector to be duplicated, got %d" % arg_num)
+            raise SimOperationError(f"expect exactly one vector to be duplicated, got {arg_num}")
         # Duplicate the vector for this many times
         vector_count = self._vector_count
         # Keep a copy of the vector to be duplicated

angr/engines/vex/heavy/__init__.py

@@ -8,9 +8,9 @@ from .super_fastpath import SuperFastpathMixin
 
 
 __all__ = (
-    "TrackActionsMixin",
+    "HeavyResilienceMixin",
     "HeavyVEXMixin",
     "SimInspectMixin",
-    "HeavyResilienceMixin",
     "SuperFastpathMixin",
+    "TrackActionsMixin",
 )

angr/engines/vex/heavy/actions.py

@@ -14,8 +14,6 @@ class TrackActionsMixin(HeavyVEXMixin):
 
         self.__tmp_deps = {}
 
-    __tls = ("__tmp_deps",)
-
     def _optimize_guarded_addr(self, addr, guard):
         addr, addr_deps = addr
         guard, _ = guard
@@ -150,7 +148,7 @@ class TrackActionsMixin(HeavyVEXMixin):
 
     # statements
 
-    def _perform_vex_stmt_WrTmp(self, tmp, data_bundle, **kwargs):
+    def _perform_vex_stmt_WrTmp(self, tmp, data_bundle, **kwargs):  # pylint:disable=unused-argument
         data, data_deps = data_bundle
 
         if o.TRACK_TMP_ACTIONS not in self.state.options:

angr/engines/vex/heavy/heavy.py

@@ -285,17 +285,15 @@ class HeavyVEXMixin(SuccessorsMixin, ClaripyDataMixin, SimStateStorageMixin, VEX
         if o.COPY_STATES not in self.state.options:
             # very special logic to try to minimize copies
             # first, check if this branch is impossible
-            if (
-                guard.is_false()
-                or o.LAZY_SOLVES not in self.state.options
+            if guard.is_false() or (
+                o.LAZY_SOLVES not in self.state.options
                 and not self.state.solver.satisfiable(extra_constraints=(guard,))
             ):
                 cont_state = self.state
 
             # then, check if it's impossible to continue from this branch
-            elif (
-                guard.is_true()
-                or o.LAZY_SOLVES not in self.state.options
+            elif guard.is_true() or (
+                o.LAZY_SOLVES not in self.state.options
                 and not self.state.solver.satisfiable(extra_constraints=(claripy.Not(guard),))
             ):
                 exit_state = self.state

angr/engines/vex/lifter.py

@@ -384,10 +384,8 @@ class VEXLifter(SimEngineBase):
 
     def __is_stop_point(self, addr, extra_stop_points=None):
         return bool(
-            self.project is not None
-            and addr in self.project._sim_procedures
-            or extra_stop_points is not None
-            and addr in extra_stop_points
+            (self.project is not None and addr in self.project._sim_procedures)
+            or (extra_stop_points is not None and addr in extra_stop_points)
         )
 
     def __getstate__(self):

angr/engines/vex/light/light.py

@@ -22,8 +22,6 @@ class VEXMixin(SimEngineBase):
         self.stmt_idx = None
         self.tmps = None
 
-    __tls = ("irsb", "stmt_idx", "tmps")
-
     def __init_handlers(self):
         self._vex_expr_handlers = [None] * pyvex.expr.tag_count
         self._vex_stmt_handlers = [None] * pyvex.stmt.tag_count

angr/engines/vex/light/slicing.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from .light import VEXMixin
+
 from angr.utils.constants import DEFAULT_STATEMENT
 
+from .light import VEXMixin
+
 
 class VEXSlicingMixin(VEXMixin):
     def __init__(self, *args, **kwargs):
@@ -12,8 +14,6 @@ class VEXSlicingMixin(VEXMixin):
         self._last_stmt = None
         self._whitelist = None
 
-    __tls = ("__no_exit_sliced", "_skip_stmts", "_last_stmt", "_whitelist")
-
     def process(self, state, block=None, skip_stmts=0, last_stmt=None, whitelist=None, **kwargs):
         self._skip_stmts = skip_stmts
         self._last_stmt = last_stmt

angr/exploration_techniques/__init__.py

@@ -26,30 +26,30 @@ from .suggestions import Suggestions
 from .stub_stasher import StubStasher
 
 __all__ = (
-    "ExplorationTechnique",
-    "Slicecutor",
+    "DFS",
+    "Bucketizer",
+    "CallFunctionGoal",
+    "Director",
     "DrillerCore",
-    "LoopSeer",
-    "Tracer",
+    "ExecuteAddressGoal",
+    "ExplorationTechnique",
     "Explorer",
-    "Threading",
-    "DFS",
     "LengthLimiter",
-    "Veritesting",
+    "LocalLoopSeer",
+    "LoopSeer",
+    "ManualMergepoint",
+    "MemoryWatcher",
     "Oppologist",
-    "Director",
-    "ExecuteAddressGoal",
-    "CallFunctionGoal",
+    "Slicecutor",
     "Spiller",
-    "ManualMergepoint",
-    "TechniqueBuilder",
     "StochasticSearch",
-    "UniqueSearch",
+    "StubStasher",
+    "Suggestions",
     "Symbion",
-    "MemoryWatcher",
-    "Bucketizer",
-    "LocalLoopSeer",
+    "TechniqueBuilder",
+    "Threading",
     "Timeout",
-    "Suggestions",
-    "StubStasher",
+    "Tracer",
+    "UniqueSearch",
+    "Veritesting",
 )

angr/exploration_techniques/threading.py

@@ -67,9 +67,3 @@ class Threading(ExplorationTechnique):
         error_list = []
         simgr.step(stash=self.local_stash, error_list=error_list, **kwargs)
         return state, error_list, simgr
-
-    def successors(self, simgr, state, engine=None, **kwargs):
-        if engine is not None:
-            l.warning("Threading exploration teqchnique does not support custom engines")
-        engine = engine or self.project.factory.default_engine
-        return simgr.successors(state, engine=engine, **kwargs)

angr/factory.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
-from typing import overload
+
 import logging
+import threading
+from typing import overload, TYPE_CHECKING
+
 import archinfo
 from archinfo.arch_soot import ArchSoot, SootAddressDescriptor
 
@@ -8,7 +11,7 @@ from .sim_state import SimState
 from .calling_conventions import default_cc, SimRegArg, SimStackArg, PointerWrapper, SimCCUnknown
 from .callable import Callable
 from .errors import AngrAssemblyError, AngrError
-from .engines import UberEngine, ProcedureEngine, SimEngineConcrete, SimEngine
+from .engines import UberEngine, ProcedureEngine, SimEngineConcrete
 from .sim_type import SimTypeFunction, SimTypeInt
 from .codenode import HookNode, SyscallNode
 from .block import Block, SootBlock
@@ -20,6 +23,10 @@ try:
 except ImportError:
     UberEnginePcode = None
 
+if TYPE_CHECKING:
+    from angr import Project, SimCC
+    from angr.engines import SimEngine
+
 
 l = logging.getLogger(name=__name__)
 
@@ -29,15 +36,26 @@ class AngrObjectFactory:
     This factory provides access to important analysis elements.
     """
 
+    project: Project
+    default_engine_factory: type[SimEngine]
+    procedure_engine: ProcedureEngine
+    concrete_engine: SimEngineConcrete | None
+    _default_cc: type[SimCC] | None
+
+    # We use thread local storage to cache engines on a per-thread basis
+    _tls: threading.local
+
     def __init__(self, project, default_engine: type[SimEngine] | None = None):
+        self._tls = threading.local()
+
         if default_engine is None:
             if isinstance(project.arch, archinfo.ArchPcode) and UberEnginePcode is not None:
                 l.warning("Creating project with the experimental 'UberEnginePcode' engine")
-                default_engine_n = UberEnginePcode
+                self.default_engine_factory = UberEnginePcode
             else:
-                default_engine_n = UberEngine
+                self.default_engine_factory = UberEngine
         else:
-            default_engine_n = default_engine
+            self.default_engine_factory = default_engine
 
         if isinstance(project.arch, archinfo.ArchPcode):
             register_pcode_arch_default_cc(project.arch)
@@ -46,7 +64,6 @@ class AngrObjectFactory:
         self._default_cc = default_cc(
             project.arch.name, platform=project.simos.name if project.simos is not None else None, default=SimCCUnknown
         )
-        self.default_engine = default_engine_n(project)
         self.procedure_engine = ProcedureEngine(project)
 
         if project.concrete_target:
@@ -54,6 +71,19 @@ class AngrObjectFactory:
         else:
             self.concrete_engine = None
 
+    def __getstate__(self):
+        return self.project, self.default_engine_factory, self.procedure_engine, self.concrete_engine, self._default_cc
+
+    def __setstate__(self, state):
+        self.project, self.default_engine_factory, self.procedure_engine, self.concrete_engine, self._default_cc = state
+        self._tls = threading.local()
+
+    @property
+    def default_engine(self):
+        if not hasattr(self._tls, "default_engine"):
+            self._tls.default_engine = self.default_engine_factory(self.project)
+        return self._tls.default_engine
+
     def snippet(self, addr, jumpkind=None, **block_opts):
         if self.project.is_hooked(addr) and jumpkind != "Ijk_NoHook":
             hook = self.project._sim_procedures[addr]

angr/keyed_region.py

@@ -13,7 +13,7 @@ l = logging.getLogger(name=__name__)
 
 
 class StoredObject:
-    __slots__ = ("__weakref__", "start", "obj", "size")
+    __slots__ = ("__weakref__", "obj", "size", "start")
 
     def __init__(self, start, obj, size):
         self.start = start
@@ -41,7 +41,7 @@ class RegionObject:
     Represents one or more objects occupying one or more bytes in KeyedRegion.
     """
 
-    __slots__ = ("start", "size", "stored_objects", "_internal_objects")
+    __slots__ = ("_internal_objects", "size", "start", "stored_objects")
 
     def __init__(self, start, size, objects=None):
         self.start = start
@@ -114,10 +114,10 @@ class KeyedRegion:
     """
 
     __slots__ = (
-        "_storage",
+        "_canonical_size",
         "_object_mapping",
         "_phi_node_contains",
-        "_canonical_size",
+        "_storage",
     )
 
     def __init__(self, tree=None, phi_node_contains=None, canonical_size=8):

angr/knowledge_base.py

@@ -49,7 +49,7 @@ class KnowledgeBase:
         object.__setattr__(self, "_project", project)
         object.__setattr__(self, "_plugins", {})
 
-        self.name = name if name else ("kb_%d" % next(kb_ctr))
+        self.name = name if name else f"kb_{next(kb_ctr)}"
 
     @property
     def callgraph(self):

angr/knowledge_plugins/__init__.py

@@ -21,23 +21,23 @@ from .obfuscations import Obfuscations
 
 
 __all__ = (
-    "FunctionManager",
-    "Function",
-    "VariableManager",
-    "DebugVariableManager",
+    "CFGManager",
+    "CallsitePrototypes",
     "Comments",
+    "CustomStrings",
     "Data",
+    "DebugVariableManager",
+    "Function",
+    "FunctionManager",
     "IndirectJumps",
-    "Labels",
-    "CFGManager",
-    "XRefManager",
+    "KeyDefinitionManager",
     "KnowledgeBasePlugin",
+    "Labels",
+    "Obfuscations",
     "PatchManager",
-    "KeyDefinitionManager",
     "PropagationManager",
     "StructuredCodeManager",
     "TypesStore",
-    "CallsitePrototypes",
-    "CustomStrings",
-    "Obfuscations",
+    "VariableManager",
+    "XRefManager",
 )

angr/knowledge_plugins/cfg/__init__.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 __all__ = (
-    "MemoryDataSort",
-    "MemoryData",
-    "CFGNode",
     "CFGENode",
+    "CFGManager",
+    "CFGModel",
+    "CFGNode",
     "IndirectJump",
     "IndirectJumpType",
-    "CFGModel",
-    "CFGManager",
+    "MemoryData",
+    "MemoryDataSort",
 )
 
 from .memory_data import MemoryDataSort, MemoryData

angr/knowledge_plugins/cfg/cfg_manager.py

@@ -18,7 +18,7 @@ class CFGManager(KnowledgeBasePlugin):
         self.cfgs = {}
 
     def __repr__(self):
-        return "<CFGManager with %d CFGs>" % len(self.cfgs)
+        return f"<CFGManager with {len(self.cfgs)} CFGs>"
 
     def __contains__(self, ident):
         return ident in self.cfgs
@@ -42,7 +42,7 @@ class CFGManager(KnowledgeBasePlugin):
         # find a unique ident
         i = 0
         while True:
-            ident = prefix + "_%d" % i
+            ident = f"{prefix}_{i}"
             if ident not in self.cfgs:
                 break
             i += 1

angr/knowledge_plugins/cfg/cfg_model.py

@@ -41,19 +41,19 @@ class CFGModel(Serializable):
     """
 
     __slots__ = (
-        "ident",
-        "graph",
-        "jump_tables",
-        "memory_data",
-        "insn_addr_to_memory_data",
-        "_nodes_by_addr",
-        "_nodes",
         "_cfg_manager",
         "_iropt_level",
         "_node_addrs",
+        "_nodes",
+        "_nodes_by_addr",
+        "edges_to_repair",
+        "graph",
+        "ident",
+        "insn_addr_to_memory_data",
         "is_arm",
+        "jump_tables",
+        "memory_data",
         "normalized",
-        "edges_to_repair",
     )
 
     def __init__(self, ident, cfg_manager=None, is_arm=False):

angr/knowledge_plugins/cfg/cfg_node.py

@@ -29,7 +29,7 @@ class CFGNodeCreationFailure:
     and the exception messages.
     """
 
-    __slots__ = ["short_reason", "long_reason", "traceback"]
+    __slots__ = ["long_reason", "short_reason", "traceback"]
 
     def __init__(self, exc_info=None, to_copy=None):
         if to_copy is None:
@@ -52,23 +52,23 @@ class CFGNode(Serializable):
     """
 
     __slots__ = (
+        "_cfg_model",
+        "_hash",
+        "_name",
         "addr",
-        "simprocedure_name",
-        "syscall_name",
-        "size",
-        "no_ret",
-        "is_syscall",
-        "function_address",
         "block_id",
-        "thumb",
         "byte_string",
-        "_name",
+        "function_address",
+        "has_return",
         "instruction_addrs",
         "irsb",
-        "has_return",
-        "_cfg_model",
-        "_hash",
+        "is_syscall",
+        "no_ret",
+        "simprocedure_name",
+        "size",
         "soot_block",
+        "syscall_name",
+        "thumb",
     )
 
     def __init__(
@@ -320,7 +320,7 @@ class CFGNode(Serializable):
         elif not isinstance(self.addr, SootAddressDescriptor):
             s += hex(self.addr)
         if self.size is not None:
-            s += "[%d]" % self.size
+            s += f"[{self.size}]"
         s += ">"
         return s
 
@@ -362,14 +362,14 @@ class CFGENode(CFGNode):
     """
 
     __slots__ = [
-        "input_state",
-        "looping_times",
+        "_callstack_key",
+        "creation_failure_info",
         "depth",
         "final_states",
-        "creation_failure_info",
+        "input_state",
+        "looping_times",
         "return_target",
         "syscall",
-        "_callstack_key",
     ]
 
     def __init__(
@@ -452,9 +452,9 @@ class CFGENode(CFGNode):
             s += self.name + " "
         s += hex(self.addr)
         if self.size is not None:
-            s += "[%d]" % self.size
+            s += f"[{self.size}]"
         if self.looping_times > 0:
-            s += " - %d" % self.looping_times
+            s += f" - {self.looping_times}"
         if self.creation_failure_info is not None:
             s += f" - creation failed: {self.creation_failure_info.long_reason}"
         s += ">"

angr/knowledge_plugins/cfg/indirect_jump.py

@@ -12,16 +12,16 @@ class IndirectJumpType:
 class IndirectJump(Serializable):
     __slots__ = (
         "addr",
-        "ins_addr",
         "func_addr",
+        "ins_addr",
         "jumpkind",
-        "stmt_idx",
-        "resolved_targets",
         "jumptable",
         "jumptable_addr",
-        "jumptable_size",
-        "jumptable_entry_size",
         "jumptable_entries",
+        "jumptable_entry_size",
+        "jumptable_size",
+        "resolved_targets",
+        "stmt_idx",
         "type",
     )
 
@@ -60,6 +60,6 @@ class IndirectJump(Serializable):
             if self.jumptable_addr is not None:
                 status += f"@{self.jumptable_addr:#08x}"
             if self.jumptable_entries is not None:
-                status += " with %d entries" % len(self.jumptable_entries)
+                status += f" with {len(self.jumptable_entries)} entries"
 
         return "<IndirectJump {:#08x} - ins {:#08x}{}>".format(self.addr, self.ins_addr, " " + status if status else "")

angr/knowledge_plugins/cfg/memory_data.py

@@ -47,12 +47,12 @@ class MemoryData(Serializable):
 
     __slots__ = (
         "addr",
-        "size",
-        "reference_size",
-        "sort",
+        "content",
         "max_size",
         "pointer_addr",
-        "content",
+        "reference_size",
+        "size",
+        "sort",
     )
 
     def __init__(
@@ -90,9 +90,7 @@ class MemoryData(Serializable):
         return self.addr
 
     def __repr__(self):
-        return "\\{:#x}, {}, {}/".format(
-            self.address, "%d bytes" % self.size if self.size is not None else "size unknown", self.sort
-        )
+        return f"\\{self.address:#x}, {self.size if self.size is not None else 'size unknown'} bytes, {self.sort}/"
 
     def copy(self):
         """