angr 9.2.132__py3-none-win_amd64.whl → 9.2.134__py3-none-win_amd64.whl

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.132"
+__version__ = "9.2.134"
 
 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/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_fast.py

@@ -100,9 +100,9 @@ class FunctionReturn:
     """
 
     __slots__ = (
+        "call_site_addr",
         "callee_func_addr",
         "caller_func_addr",
-        "call_site_addr",
         "return_to",
     )
 
@@ -287,9 +287,9 @@ class FunctionEdge:
     """
 
     __slots__ = (
+        "ins_addr",
         "src_func_addr",
         "stmt_idx",
-        "ins_addr",
     )
 
     def apply(self, cfg):
@@ -302,11 +302,11 @@ class FunctionTransitionEdge(FunctionEdge):
     """
 
     __slots__ = (
-        "src_node",
         "dst_addr",
-        "to_outside",
         "dst_func_addr",
         "is_exception",
+        "src_node",
+        "to_outside",
     )
 
     def __init__(
@@ -353,7 +353,7 @@ class FunctionCallEdge(FunctionEdge):
     Describes a call edge in functions' transition graphs.
     """
 
-    __slots__ = ("src_node", "dst_addr", "ret_addr", "syscall")
+    __slots__ = ("dst_addr", "ret_addr", "src_node", "syscall")
 
     def __init__(self, src_node, dst_addr, ret_addr, src_func_addr, syscall=False, stmt_idx=None, ins_addr=None):
         self.src_node = src_node
@@ -380,7 +380,7 @@ class FunctionFakeRetEdge(FunctionEdge):
     Describes a FakeReturn (also called fall-through) edge in functions' transition graphs.
     """
 
-    __slots__ = ("src_node", "dst_addr", "confirmed")
+    __slots__ = ("confirmed", "dst_addr", "src_node")
 
     def __init__(self, src_node, dst_addr, src_func_addr, confirmed=None):
         self.src_node = src_node
@@ -402,7 +402,7 @@ class FunctionReturnEdge(FunctionEdge):
     Describes a return (from a function call or a syscall) edge in functions' transition graphs.
     """
 
-    __slots__ = ("ret_from_addr", "ret_to_addr", "dst_func_addr")
+    __slots__ = ("dst_func_addr", "ret_from_addr", "ret_to_addr")
 
     def __init__(self, ret_from_addr, ret_to_addr, dst_func_addr):
         self.ret_from_addr = ret_from_addr
@@ -437,19 +437,19 @@ class CFGJob:
     """
 
     __slots__ = (
+        "_func_edges",
         "addr",
         "func_addr",
+        "gp",
+        "job_type",
         "jumpkind",
-        "ret_target",
         "last_addr",
-        "src_node",
+        "ret_target",
+        "returning_source",
         "src_ins_addr",
+        "src_node",
         "src_stmt_idx",
-        "returning_source",
         "syscall",
-        "_func_edges",
-        "job_type",
-        "gp",
     )
 
     def __init__(
@@ -1812,7 +1812,8 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
                         elif (
                             not security_init_cookie_found
                             and is_function_security_init_cookie(func, self.project, security_cookie_addr)
-                            or not security_init_cookie_found
+                        ) or (
+                            not security_init_cookie_found
                             and is_function_security_init_cookie_win8(func, self.project, security_cookie_addr)
                         ):
                             security_init_cookie_found = True
@@ -3036,7 +3037,8 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         self.kb.xrefs.add_xref(cr)
 
         if is_arm_arch(self.project.arch) and (
-            (irsb_addr & 1) == 1 and data_addr == (insn_addr & 0xFFFF_FFFF_FFFF_FFFE) + 4 or data_addr == insn_addr + 8
+            ((irsb_addr & 1) == 1 and data_addr == (insn_addr & 0xFFFF_FFFF_FFFF_FFFE) + 4)
+            or data_addr == insn_addr + 8
         ):
             return
         self.insn_addr_to_memory_data[insn_addr] = self.model.memory_data[data_addr]

angr/analyses/cfg/indirect_jump_resolvers/__init__.py

@@ -12,13 +12,13 @@ from .amd64_pe_iat import AMD64PeIatResolver
 
 
 __all__ = (
+    "AMD64ElfGotResolver",
+    "AMD64PeIatResolver",
+    "ArmElfFastResolver",
+    "ConstantResolver",
+    "JumpTableResolver",
     "MipsElfFastResolver",
     "MipsElfGotResolver",
     "X86ElfPicPltResolver",
-    "JumpTableResolver",
     "X86PeIatResolver",
-    "AMD64ElfGotResolver",
-    "ArmElfFastResolver",
-    "ConstantResolver",
-    "AMD64PeIatResolver",
 )

angr/analyses/cfg/indirect_jump_resolvers/amd64_elf_got.py

@@ -19,7 +19,7 @@ class AMD64ElfGotResolver(IndirectJumpResolver):
         super().__init__(project, timeless=True)
 
     def filter(self, cfg, addr, func_addr, block, jumpkind):
-        return jumpkind == "Ijk_Call" or jumpkind == "Ijk_Boring" and addr == func_addr
+        return jumpkind == "Ijk_Call" or (jumpkind == "Ijk_Boring" and addr == func_addr)
 
     def resolve(  # pylint:disable=unused-argument
         self, cfg, addr, func_addr, block, jumpkind, func_graph_complete: bool = True, **kwargs