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

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.131"
+__version__ = "9.2.133"
 
 if bytes is str:
     raise Exception(
@@ -202,162 +202,162 @@ loggers.load_all_loggers()
 load_external_definitions()
 
 __all__ = (
-    "SimProcedure",
-    "SIM_PROCEDURES",
-    "SIM_LIBRARIES",
-    "SIM_TYPE_COLLECTIONS",
-    "sim_options",
-    "options",
-    "BP_BEFORE",
+    "BP",
     "BP_AFTER",
+    "BP_BEFORE",
     "BP_BOTH",
     "BP_IPDB",
     "BP_IPYTHON",
-    "BP",
-    "SimStatePlugin",
-    "Project",
-    "load_shellcode",
-    "AngrError",
-    "AngrRuntimeError",
-    "AngrValueError",
-    "AngrLifterError",
-    "AngrExitError",
-    "AngrPathError",
-    "AngrVaultError",
-    "PathUnreachableError",
-    "SimulationManagerError",
-    "AngrInvalidArgumentError",
-    "AngrSurveyorError",
+    "DEFAULT_CC",
+    "SIM_LIBRARIES",
+    "SIM_PROCEDURES",
+    "SIM_TYPE_COLLECTIONS",
+    "SYSCALL_CC",
+    "Analysis",
     "AngrAnalysisError",
-    "AngrBladeError",
-    "AngrBladeSimProcError",
     "AngrAnnotatedCFGError",
+    "AngrAssemblyError",
     "AngrBackwardSlicingError",
+    "AngrBladeError",
+    "AngrBladeSimProcError",
+    "AngrCFGError",
     "AngrCallableError",
     "AngrCallableMultistateError",
-    "AngrSyscallError",
-    "AngrSimOSError",
-    "AngrAssemblyError",
-    "AngrTypeError",
-    "AngrMissingTypeError",
-    "AngrIncongruencyError",
-    "AngrForwardAnalysisError",
-    "AngrSkipJobNotice",
+    "AngrCorruptDBError",
+    "AngrDBError",
+    "AngrDDGError",
+    "AngrDataGraphError",
+    "AngrDecompilationError",
     "AngrDelayJobNotice",
+    "AngrDirectorError",
+    "AngrError",
+    "AngrExitError",
+    "AngrExplorationTechniqueError",
+    "AngrExplorerError",
+    "AngrForwardAnalysisError",
+    "AngrIncompatibleDBError",
+    "AngrIncongruencyError",
+    "AngrInvalidArgumentError",
     "AngrJobMergingFailureNotice",
     "AngrJobWideningFailureNotice",
-    "AngrCFGError",
-    "AngrVFGError",
-    "AngrVFGRestartAnalysisNotice",
-    "AngrDataGraphError",
-    "AngrDDGError",
+    "AngrLifterError",
     "AngrLoopAnalysisError",
-    "AngrExplorationTechniqueError",
-    "AngrExplorerError",
-    "AngrDirectorError",
+    "AngrMissingTypeError",
+    "AngrNoPluginError",
+    "AngrPathError",
+    "AngrRuntimeError",
+    "AngrSimOSError",
+    "AngrSkipJobNotice",
+    "AngrSurveyorError",
+    "AngrSyscallError",
     "AngrTracerError",
-    "AngrDBError",
-    "AngrCorruptDBError",
-    "AngrIncompatibleDBError",
-    "TracerEnvironmentError",
-    "SimError",
-    "SimStateError",
-    "SimMergeError",
-    "SimMemoryError",
-    "SimMemoryMissingError",
+    "AngrTypeError",
+    "AngrUnsupportedSyscallError",
+    "AngrVFGError",
+    "AngrVFGRestartAnalysisNotice",
+    "AngrValueError",
+    "AngrVaultError",
+    "Blade",
+    "Block",
+    "ExplorationTechnique",
+    "KnowledgeBase",
+    "PTChunk",
+    "PathUnreachableError",
+    "PointerWrapper",
+    "Project",
+    "Server",
     "SimAbstractMemoryError",
-    "SimRegionMapError",
-    "SimMemoryLimitError",
-    "SimMemoryAddressError",
-    "SimFastMemoryError",
+    "SimActionError",
+    "SimCC",
+    "SimCCError",
+    "SimCCallError",
+    "SimConcreteBreakpointError",
+    "SimConcreteMemoryError",
+    "SimConcreteRegisterError",
+    "SimEmptyCallStackError",
+    "SimEngineError",
+    "SimError",
     "SimEventError",
-    "SimPosixError",
-    "SimFilesystemError",
-    "SimSymbolicFilesystemError",
+    "SimException",
+    "SimExpressionError",
+    "SimFastMemoryError",
+    "SimFastPathError",
+    "SimFile",
+    "SimFileBase",
+    "SimFileDescriptor",
+    "SimFileDescriptorDuplex",
     "SimFileError",
+    "SimFileStream",
+    "SimFilesystemError",
+    "SimHeapBrk",
     "SimHeapError",
-    "SimUnsupportedError",
+    "SimHeapPTMalloc",
+    "SimHostFilesystem",
+    "SimIRSBError",
+    "SimIRSBNoDecodeError",
+    "SimMemoryAddressError",
+    "SimMemoryError",
+    "SimMemoryLimitError",
+    "SimMemoryMissingError",
+    "SimMergeError",
+    "SimMissingTempError",
+    "SimMount",
+    "SimOS",
+    "SimOperationError",
+    "SimPackets",
+    "SimPacketsStream",
+    "SimPosixError",
+    "SimProcedure",
+    "SimProcedureArgumentError",
+    "SimProcedureError",
+    "SimProcedures",
+    "SimRegionMapError",
+    "SimReliftException",
+    "SimSegfaultError",
+    "SimSegfaultException",
+    "SimShadowStackError",
+    "SimSlicerError",
     "SimSolverError",
     "SimSolverModeError",
     "SimSolverOptionError",
-    "SimValueError",
-    "SimUnsatError",
-    "SimOperationError",
-    "UnsupportedIROpError",
-    "SimExpressionError",
-    "UnsupportedIRExprError",
-    "SimCCallError",
-    "UnsupportedCCallError",
-    "SimUninitializedAccessError",
+    "SimState",
+    "SimStateError",
+    "SimStateOptionsError",
+    "SimStatePlugin",
     "SimStatementError",
-    "UnsupportedIRStmtError",
-    "UnsupportedDirtyError",
-    "SimMissingTempError",
-    "SimEngineError",
-    "SimIRSBError",
+    "SimSymbolicFilesystemError",
     "SimTranslationError",
-    "SimProcedureError",
-    "SimProcedureArgumentError",
-    "SimShadowStackError",
-    "SimFastPathError",
-    "SimIRSBNoDecodeError",
-    "AngrUnsupportedSyscallError",
-    "UnsupportedSyscallError",
-    "SimReliftException",
-    "SimSlicerError",
-    "SimActionError",
-    "SimCCError",
-    "SimUCManagerError",
     "SimUCManagerAllocationError",
-    "SimUnicornUnsupport",
+    "SimUCManagerError",
     "SimUnicornError",
     "SimUnicornSymbolic",
-    "SimEmptyCallStackError",
-    "SimStateOptionsError",
-    "SimException",
-    "SimSegfaultException",
-    "SimSegfaultError",
+    "SimUnicornUnsupport",
+    "SimUninitializedAccessError",
+    "SimUnsatError",
+    "SimUnsupportedError",
+    "SimValueError",
     "SimZeroDivisionException",
-    "AngrNoPluginError",
-    "SimConcreteMemoryError",
-    "SimConcreteRegisterError",
-    "SimConcreteBreakpointError",
-    "AngrDecompilationError",
-    "UnsupportedNodeTypeError",
-    "Blade",
-    "SimOS",
-    "Block",
     "SimulationManager",
-    "Analysis",
-    "register_analysis",
-    "analyses",
-    "knowledge_plugins",
-    "exploration_techniques",
-    "ExplorationTechnique",
-    "types",
+    "SimulationManagerError",
     "StateHierarchy",
-    "SimState",
-    "engines",
-    "DEFAULT_CC",
-    "default_cc",
-    "SYSCALL_CC",
-    "PointerWrapper",
-    "SimCC",
-    "SimFileBase",
-    "SimFile",
-    "SimPackets",
-    "SimFileStream",
-    "SimPacketsStream",
-    "SimFileDescriptor",
-    "SimFileDescriptorDuplex",
-    "SimMount",
-    "SimHostFilesystem",
-    "SimHeapBrk",
-    "SimHeapPTMalloc",
-    "PTChunk",
+    "TracerEnvironmentError",
+    "UnsupportedCCallError",
+    "UnsupportedDirtyError",
+    "UnsupportedIRExprError",
+    "UnsupportedIROpError",
+    "UnsupportedIRStmtError",
+    "UnsupportedNodeTypeError",
+    "UnsupportedSyscallError",
+    "analyses",
     "concretization_strategies",
-    "Server",
+    "default_cc",
+    "engines",
+    "exploration_techniques",
+    "knowledge_plugins",
+    "load_shellcode",
     "manager",
-    "SimProcedures",
-    "KnowledgeBase",
+    "options",
+    "register_analysis",
+    "sim_options",
+    "types",
 )

angr/analyses/__init__.py

@@ -58,59 +58,59 @@ from . import deobfuscator
 
 
 __all__ = (
-    "Analysis",
-    "AnalysesHub",
-    "register_analysis",
-    "ForwardAnalysis",
-    "visitors",
-    "PropagatorAnalysis",
-    "CFGFast",
-    "CFGEmulated",
-    "CFG",
-    "CFGArchOptions",
-    "CFGFastSoot",
     "CDG",
+    "CFG",
     "DDG",
     "VFG",
-    "BoyScout",
-    "BackwardSlice",
-    "Veritesting",
     "VSA_DDG",
+    "AnalysesHub",
+    "Analysis",
+    "BackwardSlice",
     "BinDiff",
-    "LoopFinder",
-    "CongruencyCheck",
-    "StaticHooker",
-    "Reassembler",
     "BinaryOptimizer",
-    "Disassembly",
-    "VariableRecovery",
-    "VariableRecoveryFast",
-    "Identifier",
+    "BoyScout",
+    "CFGArchOptions",
+    "CFGEmulated",
+    "CFGFast",
+    "CFGFastSoot",
     "CalleeCleanupFinder",
-    "ReachingDefinitionsAnalysis",
     "CallingConventionAnalysis",
+    "ClassIdentifier",
+    "CodeCaveAnalysis",
     "CodeTagging",
-    "StackPointerTracker",
-    "DominanceFrontier",
+    "CompleteCallingConventionsAnalysis",
+    "CongruencyCheck",
     "DataDependencyGraphAnalysis",
     "Decompiler",
-    "SootClassHierarchy",
-    "XRefsAnalysis",
+    "Disassembly",
+    "DominanceFrontier",
+    "FlirtAnalysis",
+    "ForwardAnalysis",
+    "Identifier",
     "InitializationFinder",
-    "CompleteCallingConventionsAnalysis",
-    "Typehoon",
+    "LoopFinder",
+    "PackingDetector",
+    "PatchFinderAnalysis",
+    "Pathfinder",
+    "PropagatorAnalysis",
     "ProximityGraphAnalysis",
-    "VtableFinder",
-    "StaticObjectFinder",
-    "ClassIdentifier",
-    "FlirtAnalysis",
+    "ReachingDefinitionsAnalysis",
+    "Reassembler",
+    "SLivenessAnalysis",
     "SPropagatorAnalysis",
     "SReachingDefinitionsAnalysis",
-    "SLivenessAnalysis",
-    "CodeCaveAnalysis",
-    "PatchFinderAnalysis",
-    "Pathfinder",
     "SelfModifyingCodeAnalysis",
-    "PackingDetector",
+    "SootClassHierarchy",
+    "StackPointerTracker",
+    "StaticHooker",
+    "StaticObjectFinder",
+    "Typehoon",
+    "VariableRecovery",
+    "VariableRecoveryFast",
+    "Veritesting",
+    "VtableFinder",
+    "XRefsAnalysis",
     "deobfuscator",
+    "register_analysis",
+    "visitors",
 )

angr/analyses/analysis.py

@@ -20,6 +20,7 @@ from rich import progress
 from angr.misc.plugins import PluginVendor, VendorPreset
 from angr.misc.ux import deprecated
 from angr.misc import telemetry
+from angr.misc.testing import is_testing
 
 if TYPE_CHECKING:
     from angr.knowledge_base import KnowledgeBase
@@ -190,11 +191,14 @@ class AnalysisFactory(Generic[A]):
 
     def prep(
         self,
-        fail_fast=False,
+        fail_fast: bool | None = None,
         kb: KnowledgeBase | None = None,
         progress_callback: Callable | None = None,
         show_progressbar: bool = False,
     ) -> type[A]:
+        if fail_fast is None:
+            fail_fast = is_testing
+
         @functools.wraps(self._analysis_cls.__init__)
         @t.start_as_current_span(self._analysis_cls.__name__)
         def wrapper(*args, **kwargs):
@@ -253,7 +257,7 @@ class AnalysisFactory(Generic[A]):
         return wrapper  # type: ignore
 
     def __call__(self, *args, **kwargs) -> A:
-        fail_fast = kwargs.pop("fail_fast", False)
+        fail_fast = kwargs.pop("fail_fast", is_testing)
         kb = kwargs.pop("kb", self._project.kb)
         progress_callback = kwargs.pop("progress_callback", None)
         show_progressbar = kwargs.pop("show_progressbar", False)

angr/analyses/backward_slice.py

@@ -110,10 +110,9 @@ class BackwardSlice(Analysis):
         s = repr(self) + "\n"
 
         if len(self.chosen_statements) > max_display:
-            s += "%d SimRuns in program slice, displaying %d.\n" % (len(self.chosen_statements), max_display)
+            s += f"{len(self.chosen_statements)} SimRuns in program slice, displaying {max_display}.\n"
         else:
-            s += "%d SimRuns in program slice.\n" % len(self.chosen_statements)
-
+            s += f"{len(self.chosen_statements)} SimRuns in program slice.\n"
         # Pretty-print the first `max_display` basic blocks
         if max_display is None:
             # Output all
@@ -150,7 +149,7 @@ class BackwardSlice(Analysis):
             statements = vex_block.statements
             for i in range(len(statements)):
                 line = "+" if i in chosen_statements else "-"
-                line += "[% 3d] " % i
+                line += f"[{i: 3d}] "
                 line += str(statements[i])
                 ss += line + "\n"
 

angr/analyses/binary_optimizer.py

@@ -35,12 +35,8 @@ class RedundantStackVariable:
         self.argument_register_as_retval = False
 
     def __repr__(self):
-        return "<StackVar %s for %s at %d locations%s>" % (
-            self.stack_variable,
-            self.argument,
-            len(self.stack_variable_consuming_locs),
-            " - retval" if self.argument_register_as_retval else "",
-        )
+        retval_str = " - retval" if self.argument_register_as_retval else ""
+        return f"<StackVar {self.stack_variable} for {self.argument} at {len(self.stack_variable_consuming_locs)} locations{retval_str}>"
 
 
 class RegisterReallocation:
@@ -79,12 +75,9 @@ class RegisterReallocation:
         self.epilogue_size = epilogue_size
 
     def __repr__(self):
-        return "<RegisterReallocation %s for %s with %d sources and %d consumers>" % (
-            self.register_variable,
-            self.stack_variable,
-            len(self.stack_variable_sources),
-            len(self.stack_variable_consumers),
-        )
+        sources_count = len(self.stack_variable_sources)
+        consumers_count = len(self.stack_variable_consumers)
+        return f"<RegisterReallocation {self.register_variable} for {self.stack_variable} with {sources_count} sources and {consumers_count} consumers>"
 
 
 class DeadAssignment:

angr/analyses/bindiff.py

@@ -208,11 +208,8 @@ def compare_statement_dict(statement_1, statement_2):
     # constants
     if isinstance(statement_1, (int, float, str, bytes)):
         if (
-            isinstance(statement_1, float)
-            and math.isnan(statement_1)
-            and math.isnan(statement_2)
-            or statement_1 == statement_2
-        ):
+            isinstance(statement_1, float) and math.isnan(statement_1) and math.isnan(statement_2)
+        ) or statement_1 == statement_2:
             return []
         return [Difference(None, statement_1, statement_2)]
 
@@ -283,7 +280,7 @@ class NormalizedBlock:
 
     def __repr__(self):
         size = sum([b.size for b in self.blocks])
-        return "<Normalized Block for %#x, %d bytes>" % (self.addr, size)
+        return f"<Normalized Block for {self.addr:#x}, {size} bytes>"
 
 
 class NormalizedFunction:

angr/analyses/calling_convention.py

@@ -277,7 +277,7 @@ class CallingConventionAnalysis(Analysis):
                     # prioritize the hooker
                     hooker = self.project.hooked_by(real_func.addr)
                     if hooker is not None and (
-                        not hooker.is_stub or hooker.is_function and not hooker.guessed_prototype
+                        not hooker.is_stub or (hooker.is_function and not hooker.guessed_prototype)
                     ):
                         return real_func.calling_convention, hooker.prototype
                 if real_func.calling_convention and real_func.prototype:
@@ -414,7 +414,7 @@ class CallingConventionAnalysis(Analysis):
 
         for src, _, data in sorted(in_edges, key=lambda x: x[0].addr):
             edge_type = data.get("jumpkind", "Ijk_Call")
-            if not (edge_type == "Ijk_Call" or edge_type == "Ijk_Boring" and self._cfg.graph.out_degree[src] == 1):
+            if not (edge_type == "Ijk_Call" or (edge_type == "Ijk_Boring" and self._cfg.graph.out_degree[src] == 1)):
                 continue
             if not self.kb.functions.contains_addr(src.function_address):
                 continue
@@ -523,8 +523,7 @@ class CallingConventionAnalysis(Analysis):
             def_
             for def_ in rda.all_uses._uses_by_definition
             if (
-                def_.codeloc.block_addr == caller_block_addr
-                and def_.codeloc.stmt_idx == DEFAULT_STATEMENT
+                (def_.codeloc.block_addr == caller_block_addr and def_.codeloc.stmt_idx == DEFAULT_STATEMENT)
                 or any(isinstance(tag, ReturnValueTag) for tag in def_.tags)
             )
         }

angr/analyses/cfg/__init__.py

@@ -13,11 +13,11 @@ from .cfg_base import CFGBase
 
 
 __all__ = (
-    "CFGFast",
-    "CFGEmulated",
     "CFG",
     "CFBlanket",
-    "CFGFastSoot",
     "CFGArchOptions",
     "CFGBase",
+    "CFGEmulated",
+    "CFGFast",
+    "CFGFastSoot",
 )

angr/analyses/cfg/cfg_base.py

@@ -111,7 +111,7 @@ class CFGBase(Analysis):
 
         # Sanity checks
         if context_sensitivity_level < 0:
-            raise ValueError("Unsupported context sensitivity level %d" % context_sensitivity_level)
+            raise ValueError(f"Unsupported context sensitivity level {context_sensitivity_level}")
 
         self._binary = binary if binary is not None else self.project.loader.main_object
         self._force_segment = force_segment

angr/analyses/cfg/cfg_emulated.py

@@ -2972,7 +2972,7 @@ class CFGEmulated(ForwardAnalysis, CFGBase):  # pylint: disable=abstract-method
                 # Skip this IRSB
                 l.debug("Caught a SimIRSBError %s. Don't panic, this is usually expected.", ex)
                 inst = SIM_PROCEDURES["stubs"]["PathTerminator"]()
-                sim_successors = ProcedureEngine().process(state, procedure=inst)
+                sim_successors = ProcedureEngine(self.project).process(state, procedure=inst)
 
         except SimIRSBError:
             exception_info = sys.exc_info()
@@ -2980,28 +2980,28 @@ class CFGEmulated(ForwardAnalysis, CFGBase):  # pylint: disable=abstract-method
             # does not support. I'll create a terminating stub there
             l.debug("Caught a SimIRSBError during CFG recovery. Creating a PathTerminator.", exc_info=True)
             inst = SIM_PROCEDURES["stubs"]["PathTerminator"]()
-            sim_successors = ProcedureEngine().process(state, procedure=inst)
+            sim_successors = ProcedureEngine(self.project).process(state, procedure=inst)
 
         except claripy.ClaripyError:
             exception_info = sys.exc_info()
             l.debug("Caught a ClaripyError during CFG recovery. Don't panic, this is usually expected.", exc_info=True)
             # Generate a PathTerminator to terminate the current path
             inst = SIM_PROCEDURES["stubs"]["PathTerminator"]()
-            sim_successors = ProcedureEngine().process(state, procedure=inst)
+            sim_successors = ProcedureEngine(self.project).process(state, procedure=inst)
 
         except SimError:
             exception_info = sys.exc_info()
             l.debug("Caught a SimError during CFG recovery. Don't panic, this is usually expected.", exc_info=True)
             # Generate a PathTerminator to terminate the current path
             inst = SIM_PROCEDURES["stubs"]["PathTerminator"]()
-            sim_successors = ProcedureEngine().process(state, procedure=inst)
+            sim_successors = ProcedureEngine(self.project).process(state, procedure=inst)
 
         except AngrExitError:
             exception_info = sys.exc_info()
             l.debug("Caught a AngrExitError during CFG recovery. Don't panic, this is usually expected.", exc_info=True)
             # Generate a PathTerminator to terminate the current path
             inst = SIM_PROCEDURES["stubs"]["PathTerminator"]()
-            sim_successors = ProcedureEngine().process(state, procedure=inst)
+            sim_successors = ProcedureEngine(self.project).process(state, procedure=inst)
 
         except AngrError:
             exception_info = sys.exc_info()