angr 9.2.131__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

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):
         """

angr/knowledge_plugins/functions/function.py

@@ -39,51 +39,51 @@ class Function(Serializable):
     """
 
     __slots__ = (
-        "transition_graph",
-        "_local_transition_graph",
-        "normalized",
-        "_ret_sites",
-        "_jumpout_sites",
+        "_addr_to_block_node",
+        "_argument_registers",
+        "_argument_stack_variables",
+        "_block_cache",
+        "_block_sizes",
+        "_call_sites",
         "_callout_sites",
+        "_cyclomatic_complexity",
         "_endpoints",
-        "_call_sites",
-        "_retout_sites",
-        "addr",
         "_function_manager",
-        "is_syscall",
+        "_jumpout_sites",
+        "_local_block_addrs",
+        "_local_blocks",
+        "_local_transition_graph",
+        "_name",
         "_project",
-        "is_plt",
+        "_ret_sites",
+        "_retout_sites",
+        "_returning",
+        "addr",
         "addr",
-        "is_simprocedure",
-        "_name",
-        "previous_names",
-        "is_default_name",
-        "from_signature",
         "binary_name",
-        "_argument_registers",
-        "_argument_stack_variables",
         "bp_on_stack",
-        "retaddr_on_stack",
-        "sp_delta",
         "calling_convention",
-        "prototype",
-        "prototype_libname",
-        "_returning",
+        "from_signature",
+        "info",
+        "is_alignment",
+        "is_default_name",
+        "is_plt",
+        "is_prototype_guessed",
+        "is_simprocedure",
+        "is_syscall",
+        "normalized",
         "prepared_registers",
         "prepared_stack_variables",
+        "previous_names",
+        "prototype",
+        "prototype_libname",
+        "ran_cca",
         "registers_read_afterwards",
+        "retaddr_on_stack",
+        "sp_delta",
         "startpoint",
-        "_addr_to_block_node",
-        "_block_sizes",
-        "_block_cache",
-        "_local_blocks",
-        "_local_block_addrs",
-        "info",
         "tags",
-        "is_alignment",
-        "is_prototype_guessed",
-        "ran_cca",
-        "_cyclomatic_complexity",
+        "transition_graph",
     )
 
     def __init__(
@@ -586,17 +586,18 @@ class Function(Serializable):
         return False
 
     def __str__(self):
-        s = f"Function {self.name} [{self.addr:#x}]\n"
-        s += f"  Syscall: {self.is_syscall}\n"
-        s += "  SP difference: %d\n" % self.sp_delta
-        s += f"  Has return: {self.has_return}\n"
-        s += "  Returning: %s\n" % ("Unknown" if self.returning is None else self.returning)
-        s += f"  Alignment: {self.alignment}\n"
-        s += f"  Arguments: reg: {self._argument_registers}, stack: {self._argument_stack_variables}\n"
-        s += "  Blocks: [{}]\n".format(", ".join([f"{i:#x}" for i in self.block_addrs]))
-        s += f"  Cyclomatic Complexity: {self.cyclomatic_complexity}\n"
-        s += f"  Calling convention: {self.calling_convention}"
-        return s
+        return (
+            f"Function {self.name} [{self.addr:#x}]\n"
+            f"  Syscall: {self.is_syscall}\n"
+            f"  SP difference: {self.sp_delta}\n"
+            f"  Has return: {self.has_return}\n"
+            f"  Returning: {'Unknown' if self.returning is None else self.returning}\n"
+            f"  Alignment: {self.alignment}\n"
+            f"  Arguments: reg: {self._argument_registers}, stack: {self._argument_stack_variables}\n"
+            f"  Blocks: [{', '.join(f'{i:#x}' for i in self.block_addrs)}]\n"
+            f"  Cyclomatic Complexity: {self.cyclomatic_complexity}\n"
+            f"  Calling convention: {self.calling_convention}"
+        )
 
     def __repr__(self):
         if self.is_syscall:
@@ -1093,10 +1094,8 @@ class Function(Serializable):
             g.add_node(block)
         for src, dst, data in self.transition_graph.edges(data=True):
             if "type" in data and (
-                data["type"] in ("transition", "exception")
-                and ("outside" not in data or data["outside"] is False)
-                or data["type"] == "fake_return"
-                and ("outside" not in data or data["outside"] is False)
+                (data["type"] in ("transition", "exception") and ("outside" not in data or data["outside"] is False))
+                or (data["type"] == "fake_return" and ("outside" not in data or data["outside"] is False))
             ):
                 g.add_edge(src, dst, **data)
 
@@ -1268,11 +1267,8 @@ class Function(Serializable):
             if b.addr <= addr < b.addr + b.size:
                 # found it
                 for i, instr_addr in enumerate(b.instruction_addrs):
-                    if (
-                        i < len(b.instruction_addrs) - 1
-                        and instr_addr <= addr < b.instruction_addrs[i + 1]
-                        or i == len(b.instruction_addrs) - 1
-                        and instr_addr <= addr
+                    if (i < len(b.instruction_addrs) - 1 and instr_addr <= addr < b.instruction_addrs[i + 1]) or (
+                        i == len(b.instruction_addrs) - 1 and instr_addr <= addr
                     ):
                         return instr_addr
                 # Not covered by any instruction... why?

angr/knowledge_plugins/functions/function_parser.py

@@ -153,10 +153,10 @@ class FunctionParser:
             dst = None
             dst_addr = edge_cmsg.dst_ea
             if (
-                dst_addr not in blocks
-                and edge_type == "call"  # call has to go to either a HookNode or a function
-                or (all_func_addrs is not None and dst_addr in all_func_addrs)  # jumps to another function
-            ):
+                dst_addr not in blocks and edge_type == "call"
+            ) or (  # call has to go to either a HookNode or a function
+                all_func_addrs is not None and dst_addr in all_func_addrs
+            ):  # jumps to another function
                 if function_manager is not None:
                     # get a function
                     dst = FunctionParser._get_func(dst_addr, function_manager)

angr/knowledge_plugins/key_definitions/__init__.py

@@ -7,11 +7,11 @@ from .definition import Definition
 from . import atoms
 
 __all__ = (
-    "ReachingDefinitionsModel",
+    "Definition",
+    "DerefSize",
     "KeyDefinitionManager",
     "LiveDefinitions",
-    "DerefSize",
+    "ReachingDefinitionsModel",
     "Uses",
     "atoms",
-    "Definition",
 )

angr/knowledge_plugins/key_definitions/atoms.py

@@ -197,7 +197,7 @@ class Tmp(Atom):
         self.tmp_idx = tmp_idx
 
     def __repr__(self):
-        return "<Tmp %d>" % self.tmp_idx
+        return f"<Tmp {self.tmp_idx}>"
 
     def _identity(self):
         return hash(("tmp", self.tmp_idx))
@@ -216,18 +216,18 @@ class Register(Atom):
     """
 
     __slots__ = (
-        "reg_offset",
         "arch",
+        "reg_offset",
     )
 
-    def __init__(self, reg_offset: RegisterOffset, size: int, arch: Arch | None = None):
+    def __init__(self, reg_offset: RegisterOffset | int, size: int, arch: Arch | None = None):
         super().__init__(size)
 
-        self.reg_offset = reg_offset
+        self.reg_offset = RegisterOffset(reg_offset)
         self.arch = arch
 
     def __repr__(self):
-        return "<Reg %s<%d>>" % (self.name, self.size)
+        return f"<Reg {self.name}<{self.size}>>"
 
     def _identity(self):
         return (self.reg_offset, self.size)
@@ -245,9 +245,9 @@ class VirtualVariable(Atom):
     """
 
     __slots__ = (
-        "varid",
         "category",
         "oident",
+        "varid",
     )
 
     def __init__(
@@ -260,7 +260,7 @@ class VirtualVariable(Atom):
         self.oident = oident
 
     def __repr__(self):
-        return "<VVar %d<%d>>" % (self.varid, self.size)
+        return f"<VVar {self.varid}<{self.size}>>"
 
     def _identity(self):
         return self.varid, self.size
@@ -323,7 +323,7 @@ class MemoryLocation(Atom):
     def __repr__(self):
         address_format = hex(self.addr) if type(self.addr) is int else self.addr
         stack_format = " (stack)" if self.is_on_stack else ""
-        size = "%d" % self.size if isinstance(self.size, int) else self.size
+        size = f"{self.size}" if isinstance(self.size, int) else self.size
 
         return f"<Mem {address_format}<{size}>{stack_format}>"
 

angr/knowledge_plugins/key_definitions/definition.py

@@ -151,11 +151,11 @@ class Definition(Generic[A]):
     """
 
     __slots__ = (
+        "_hash",
         "atom",
         "codeloc",
         "dummy",
         "tags",
-        "_hash",
     )
 
     def __init__(self, atom: A, codeloc: CodeLocation, dummy: bool = False, tags: set[Tag] | None = None):