angr 9.2.118__py3-none-manylinux2014_aarch64.whl → 9.2.120__py3-none-manylinux2014_aarch64.whl

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.118"
+__version__ = "9.2.120"
 
 if bytes is str:
     raise Exception(
@@ -53,7 +53,115 @@ from .state_plugins.inspect import BP
 from .state_plugins import SimStatePlugin
 
 from .project import Project, load_shellcode
-from .errors import *
+from .errors import (
+    AngrError,
+    AngrRuntimeError,
+    AngrValueError,
+    AngrLifterError,
+    AngrExitError,
+    AngrPathError,
+    AngrVaultError,
+    PathUnreachableError,
+    SimulationManagerError,
+    AngrInvalidArgumentError,
+    AngrSurveyorError,
+    AngrAnalysisError,
+    AngrBladeError,
+    AngrBladeSimProcError,
+    AngrAnnotatedCFGError,
+    AngrBackwardSlicingError,
+    AngrCallableError,
+    AngrCallableMultistateError,
+    AngrSyscallError,
+    AngrSimOSError,
+    AngrAssemblyError,
+    AngrTypeError,
+    AngrMissingTypeError,
+    AngrIncongruencyError,
+    AngrForwardAnalysisError,
+    AngrSkipJobNotice,
+    AngrDelayJobNotice,
+    AngrJobMergingFailureNotice,
+    AngrJobWideningFailureNotice,
+    AngrCFGError,
+    AngrVFGError,
+    AngrVFGRestartAnalysisNotice,
+    AngrDataGraphError,
+    AngrDDGError,
+    AngrLoopAnalysisError,
+    AngrExplorationTechniqueError,
+    AngrExplorerError,
+    AngrDirectorError,
+    AngrTracerError,
+    AngrDBError,
+    AngrCorruptDBError,
+    AngrIncompatibleDBError,
+    TracerEnvironmentError,
+    SimError,
+    SimStateError,
+    SimMergeError,
+    SimMemoryError,
+    SimMemoryMissingError,
+    SimAbstractMemoryError,
+    SimRegionMapError,
+    SimMemoryLimitError,
+    SimMemoryAddressError,
+    SimFastMemoryError,
+    SimEventError,
+    SimPosixError,
+    SimFilesystemError,
+    SimSymbolicFilesystemError,
+    SimFileError,
+    SimHeapError,
+    SimUnsupportedError,
+    SimSolverError,
+    SimSolverModeError,
+    SimSolverOptionError,
+    SimValueError,
+    SimUnsatError,
+    SimOperationError,
+    UnsupportedIROpError,
+    SimExpressionError,
+    UnsupportedIRExprError,
+    SimCCallError,
+    UnsupportedCCallError,
+    SimUninitializedAccessError,
+    SimStatementError,
+    UnsupportedIRStmtError,
+    UnsupportedDirtyError,
+    SimMissingTempError,
+    SimEngineError,
+    SimIRSBError,
+    SimTranslationError,
+    SimProcedureError,
+    SimProcedureArgumentError,
+    SimShadowStackError,
+    SimFastPathError,
+    SimIRSBNoDecodeError,
+    AngrUnsupportedSyscallError,
+    UnsupportedSyscallError,
+    SimReliftException,
+    SimSlicerError,
+    SimActionError,
+    SimCCError,
+    SimUCManagerError,
+    SimUCManagerAllocationError,
+    SimUnicornUnsupport,
+    SimUnicornError,
+    SimUnicornSymbolic,
+    SimEmptyCallStackError,
+    SimStateOptionsError,
+    SimException,
+    SimSegfaultException,
+    SimSegfaultError,
+    SimZeroDivisionException,
+    AngrNoPluginError,
+    SimConcreteMemoryError,
+    SimConcreteRegisterError,
+    SimConcreteBreakpointError,
+    AngrDecompilationError,
+    UnsupportedNodeTypeError,
+)
 from .blade import Blade
 from .simos import SimOS
 from .block import Block
@@ -109,6 +217,113 @@ __all__ = (
     "SimStatePlugin",
     "Project",
     "load_shellcode",
+    "AngrError",
+    "AngrRuntimeError",
+    "AngrValueError",
+    "AngrLifterError",
+    "AngrExitError",
+    "AngrPathError",
+    "AngrVaultError",
+    "PathUnreachableError",
+    "SimulationManagerError",
+    "AngrInvalidArgumentError",
+    "AngrSurveyorError",
+    "AngrAnalysisError",
+    "AngrBladeError",
+    "AngrBladeSimProcError",
+    "AngrAnnotatedCFGError",
+    "AngrBackwardSlicingError",
+    "AngrCallableError",
+    "AngrCallableMultistateError",
+    "AngrSyscallError",
+    "AngrSimOSError",
+    "AngrAssemblyError",
+    "AngrTypeError",
+    "AngrMissingTypeError",
+    "AngrIncongruencyError",
+    "AngrForwardAnalysisError",
+    "AngrSkipJobNotice",
+    "AngrDelayJobNotice",
+    "AngrJobMergingFailureNotice",
+    "AngrJobWideningFailureNotice",
+    "AngrCFGError",
+    "AngrVFGError",
+    "AngrVFGRestartAnalysisNotice",
+    "AngrDataGraphError",
+    "AngrDDGError",
+    "AngrLoopAnalysisError",
+    "AngrExplorationTechniqueError",
+    "AngrExplorerError",
+    "AngrDirectorError",
+    "AngrTracerError",
+    "AngrDBError",
+    "AngrCorruptDBError",
+    "AngrIncompatibleDBError",
+    "TracerEnvironmentError",
+    "SimError",
+    "SimStateError",
+    "SimMergeError",
+    "SimMemoryError",
+    "SimMemoryMissingError",
+    "SimAbstractMemoryError",
+    "SimRegionMapError",
+    "SimMemoryLimitError",
+    "SimMemoryAddressError",
+    "SimFastMemoryError",
+    "SimEventError",
+    "SimPosixError",
+    "SimFilesystemError",
+    "SimSymbolicFilesystemError",
+    "SimFileError",
+    "SimHeapError",
+    "SimUnsupportedError",
+    "SimSolverError",
+    "SimSolverModeError",
+    "SimSolverOptionError",
+    "SimValueError",
+    "SimUnsatError",
+    "SimOperationError",
+    "UnsupportedIROpError",
+    "SimExpressionError",
+    "UnsupportedIRExprError",
+    "SimCCallError",
+    "UnsupportedCCallError",
+    "SimUninitializedAccessError",
+    "SimStatementError",
+    "UnsupportedIRStmtError",
+    "UnsupportedDirtyError",
+    "SimMissingTempError",
+    "SimEngineError",
+    "SimIRSBError",
+    "SimTranslationError",
+    "SimProcedureError",
+    "SimProcedureArgumentError",
+    "SimShadowStackError",
+    "SimFastPathError",
+    "SimIRSBNoDecodeError",
+    "AngrUnsupportedSyscallError",
+    "UnsupportedSyscallError",
+    "SimReliftException",
+    "SimSlicerError",
+    "SimActionError",
+    "SimCCError",
+    "SimUCManagerError",
+    "SimUCManagerAllocationError",
+    "SimUnicornUnsupport",
+    "SimUnicornError",
+    "SimUnicornSymbolic",
+    "SimEmptyCallStackError",
+    "SimStateOptionsError",
+    "SimException",
+    "SimSegfaultException",
+    "SimSegfaultError",
+    "SimZeroDivisionException",
+    "AngrNoPluginError",
+    "SimConcreteMemoryError",
+    "SimConcreteRegisterError",
+    "SimConcreteBreakpointError",
+    "AngrDecompilationError",
+    "UnsupportedNodeTypeError",
     "Blade",
     "SimOS",
     "Block",

angr/__main__.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
+
 import argparse
+import sys
 
+from angr.analyses.decompiler import DECOMPILATION_PRESETS
 from angr.analyses.decompiler.structuring import STRUCTURER_CLASSES, DEFAULT_STRUCTURER
 from angr.analyses.decompiler.utils import decompile_functions
 
@@ -14,7 +17,7 @@ class COMMANDS:
     ALL_COMMANDS = [DECOMPILE]
 
 
-def main():
+def main(args=sys.argv[1:], out=sys.stdout):
     parser = argparse.ArgumentParser(description="The angr CLI allows you to decompile and analyze binaries.")
     parser.add_argument(
         "command",
@@ -59,8 +62,14 @@ def main():
         action="store_true",
         default=False,
     )
+    parser.add_argument(
+        "--preset",
+        help="The configuration preset to use for decompilation.",
+        choices=DECOMPILATION_PRESETS,
+        default="default",
+    )
 
-    args = parser.parse_args()
+    args = parser.parse_args(args)
     if args.command == COMMANDS.DECOMPILE:
         decompilation = decompile_functions(
             args.binary,
@@ -69,10 +78,11 @@ def main():
             catch_errors=args.catch_exceptions,
             show_casts=not args.no_casts,
             base_address=args.base_addr,
+            preset=args.preset,
         )
-        print(decompilation)
+        print(decompilation, file=out)
     else:
-        parser.print_help()
+        parser.print_help(file=out)
 
 
 if __name__ == "__main__":

angr/analyses/__init__.py

@@ -1,5 +1,6 @@
 # pylint:disable=wrong-import-position
 from __future__ import annotations
+
 from .analysis import Analysis, AnalysesHub
 
 
@@ -48,3 +49,56 @@ from .flirt import FlirtAnalysis
 from .s_propagator import SPropagatorAnalysis
 from .s_reaching_definitions import SReachingDefinitionsAnalysis
 from .s_liveness import SLivenessAnalysis
+
+
+__all__ = (
+    "Analysis",
+    "AnalysesHub",
+    "register_analysis",
+    "ForwardAnalysis",
+    "visitors",
+    "PropagatorAnalysis",
+    "CFGFast",
+    "CFGEmulated",
+    "CFG",
+    "CFGArchOptions",
+    "CFGFastSoot",
+    "CDG",
+    "DDG",
+    "VFG",
+    "BoyScout",
+    "BackwardSlice",
+    "Veritesting",
+    "VSA_DDG",
+    "BinDiff",
+    "LoopFinder",
+    "CongruencyCheck",
+    "StaticHooker",
+    "Reassembler",
+    "BinaryOptimizer",
+    "Disassembly",
+    "VariableRecovery",
+    "VariableRecoveryFast",
+    "Identifier",
+    "CalleeCleanupFinder",
+    "ReachingDefinitionsAnalysis",
+    "CallingConventionAnalysis",
+    "CodeTagging",
+    "StackPointerTracker",
+    "DominanceFrontier",
+    "DataDependencyGraphAnalysis",
+    "Decompiler",
+    "SootClassHierarchy",
+    "XRefsAnalysis",
+    "InitializationFinder",
+    "CompleteCallingConventionsAnalysis",
+    "Typehoon",
+    "ProximityGraphAnalysis",
+    "VtableFinder",
+    "StaticObjectFinder",
+    "ClassIdentifier",
+    "FlirtAnalysis",
+    "SPropagatorAnalysis",
+    "SReachingDefinitionsAnalysis",
+    "SLivenessAnalysis",
+)

angr/analyses/analysis.py

@@ -5,8 +5,10 @@ import sys
 import contextlib
 from collections import defaultdict
 from inspect import Signature
-from typing import TYPE_CHECKING, TypeVar, Type, Generic, Optional
+from typing import TYPE_CHECKING, TypeVar, Generic, cast
 from collections.abc import Callable
+from types import NoneType
+from itertools import chain
 
 import logging
 import time
@@ -14,12 +16,13 @@ import typing
 
 from rich import progress
 
-from ..misc.plugins import PluginVendor, VendorPreset
-from ..misc.ux import deprecated
+from angr.misc.plugins import PluginVendor, VendorPreset
+from angr.misc.ux import deprecated
+from angr.misc import telemetry
 
 if TYPE_CHECKING:
-    from ..knowledge_base import KnowledgeBase
-    from ..project import Project
+    from angr.knowledge_base import KnowledgeBase
+    from angr.project import Project
     from typing_extensions import ParamSpec
     from .identifier import Identifier
     from .callee_cleanup_finder import CalleeCleanupFinder
@@ -55,6 +58,7 @@ if TYPE_CHECKING:
     AnalysisParams = ParamSpec("AnalysisParams")
 
 l = logging.getLogger(name=__name__)
+t = telemetry.get_tracer(name=__name__)
 
 
 class AnalysisLogEntry:
@@ -186,7 +190,45 @@ class AnalysisFactory(Generic[A]):
         show_progressbar: bool = False,
     ) -> type[A]:
         @functools.wraps(self._analysis_cls.__init__)
+        @t.start_as_current_span(self._analysis_cls.__name__)
         def wrapper(*args, **kwargs):
+            span = telemetry.get_current_span()
+            sig = cast(Signature, self.__call__.__func__.__signature__)
+            bound = sig.bind(None, *args, **kwargs)
+            for name, val in chain(bound.arguments.items(), bound.arguments.get("kwargs", {}).items()):
+                if name in ("kwargs", "self"):
+                    continue
+                if isinstance(val, (str, bytes, bool, int, float, NoneType)):
+                    if val is None:
+                        span.set_attribute(f"arg.{name}.is_none", True)
+                    else:
+                        span.set_attribute(f"arg.{name}", val)
+                elif isinstance(val, (list, tuple, set, frozenset)):
+                    listval = list(val)
+                    if not listval or (
+                        isinstance(listval[0], (str, bytes, bool, int, float))
+                        and all(type(sval) is type(listval[0]) for sval in listval)
+                    ):
+                        span.set_attribute(f"arg.{name}", listval)
+                elif isinstance(val, dict):
+                    listval_keys = list(val)
+                    listval_values = list(val.values())
+                    if not listval_keys or (
+                        isinstance(listval_keys[0], (str, bytes, bool, int, float))
+                        and all(type(sval) is type(listval_keys[0]) for sval in listval_keys)
+                    ):
+                        span.set_attribute(f"arg.{name}.keys", listval_keys)
+                    if not listval_values or (
+                        isinstance(listval_values[0], (str, bytes, bool, int, float))
+                        and all(type(sval) is type(listval_values[0]) for sval in listval_values)
+                    ):
+                        span.set_attribute(f"arg.{name}.values", listval_values)
+                else:
+                    span.set_attribute(f"arg.{name}.unrepresentable", True)
+            if self._project.filename is not None:
+                span.set_attribute("project.binary_name", self._project.filename)
+            span.set_attribute("project.arch_name", self._project.arch.name)
+
             oself = object.__new__(self._analysis_cls)
             oself.named_errors = defaultdict(list)
             oself.errors = []

angr/analyses/backward_slice.py

@@ -6,10 +6,10 @@ import networkx
 import pyvex
 from . import Analysis
 
-from ..code_location import CodeLocation
-from ..annocfg import AnnotatedCFG
-from ..errors import AngrBackwardSlicingError
-from ..utils.constants import DEFAULT_STATEMENT
+from angr.code_location import CodeLocation
+from angr.annocfg import AnnotatedCFG
+from angr.errors import AngrBackwardSlicingError
+from angr.utils.constants import DEFAULT_STATEMENT
 
 
 l = logging.getLogger(name=__name__)

angr/analyses/bindiff.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 from . import Analysis, CFGEmulated
 
-from ..errors import SimEngineError, SimMemoryError
+from angr.errors import SimEngineError, SimMemoryError
 
 # todo include an explanation of the algorithm
 # todo include a method that detects any change other than constants
@@ -198,7 +198,7 @@ def compare_statement_dict(statement_1, statement_2):
     # should return whether or not the statement's type/effects changed
     # need to return the specific number that changed too
 
-    if type(statement_1) != type(statement_2):
+    if type(statement_1) is not type(statement_2):
         return [Difference(DIFF_TYPE, None, None)]
 
     # None

angr/analyses/callee_cleanup_finder.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from . import Analysis
-from .. import SIM_PROCEDURES
+from angr import SIM_PROCEDURES
 
 import logging
 

angr/analyses/calling_convention.py

@@ -14,8 +14,8 @@ import ailment
 
 from angr.code_location import ExternalCodeLocation
 
-from ..calling_conventions import SimFunctionArgument, SimRegArg, SimStackArg, SimCC, default_cc
-from ..sim_type import (
+from angr.calling_conventions import SimFunctionArgument, SimRegArg, SimStackArg, SimCC, default_cc
+from angr.sim_type import (
     SimTypeInt,
     SimTypeFunction,
     SimType,
@@ -26,22 +26,22 @@ from ..sim_type import (
     SimTypeFloat,
     SimTypeDouble,
 )
-from ..sim_variable import SimStackVariable, SimRegisterVariable
-from ..knowledge_plugins.key_definitions.atoms import Register, MemoryLocation, SpOffset
-from ..knowledge_plugins.key_definitions.tag import ReturnValueTag
-from ..knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
-from ..knowledge_plugins.key_definitions.rd_model import ReachingDefinitionsModel
-from ..knowledge_plugins.variables.variable_access import VariableAccessSort
-from ..knowledge_plugins.functions import Function
-from ..utils.constants import DEFAULT_STATEMENT
-from .. import SIM_PROCEDURES
+from angr.sim_variable import SimStackVariable, SimRegisterVariable
+from angr.knowledge_plugins.key_definitions.atoms import Register, MemoryLocation, SpOffset
+from angr.knowledge_plugins.key_definitions.tag import ReturnValueTag
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
+from angr.knowledge_plugins.key_definitions.rd_model import ReachingDefinitionsModel
+from angr.knowledge_plugins.variables.variable_access import VariableAccessSort
+from angr.knowledge_plugins.functions import Function
+from angr.utils.constants import DEFAULT_STATEMENT
+from angr import SIM_PROCEDURES
 from .reaching_definitions import get_all_definitions
 from . import Analysis, register_analysis, ReachingDefinitionsAnalysis
 
 if TYPE_CHECKING:
-    from ..knowledge_plugins.cfg import CFGModel
-    from ..knowledge_plugins.key_definitions.uses import Uses
-    from ..knowledge_plugins.key_definitions.definition import Definition
+    from angr.knowledge_plugins.cfg import CFGModel
+    from angr.knowledge_plugins.key_definitions.uses import Uses
+    from angr.knowledge_plugins.key_definitions.definition import Definition
 
 l = logging.getLogger(name=__name__)
 
@@ -557,7 +557,13 @@ class CallingConventionAnalysis(Analysis):
         fact: CallSiteFact,
     ) -> None:
         # determine if potential register and stack arguments are set
-        state = rda.observed_results[("insn", call_insn_addr, OP_BEFORE)]
+        observation_key = "insn", call_insn_addr, OP_BEFORE
+        state = rda.observed_results.get(observation_key)
+        if state is None:
+            # the observation state is not found. it can happen if call_insn_addr is incorrect, which may happen (but
+            # rarely) on incorrect CFGs.
+            return
+
         defs_by_reg_offset: dict[int, list[Definition]] = defaultdict(list)
         all_reg_defs: set[Definition] = get_all_definitions(state.registers)
         all_stack_defs: set[Definition] = get_all_definitions(state.stack)

angr/analyses/cdg.py

@@ -3,7 +3,7 @@ import logging
 
 import networkx
 
-from ..utils.graph import compute_dominance_frontier, PostDominators, TemporaryNode
+from angr.utils.graph import compute_dominance_frontier, PostDominators, TemporaryNode
 from . import Analysis
 
 _l = logging.getLogger(name=__name__)

angr/analyses/cfg/__init__.py

@@ -1,5 +1,6 @@
 # analyses
 from __future__ import annotations
+
 from .cfg_fast import CFGFast
 from .cfg_emulated import CFGEmulated
 from .cfg import CFG
@@ -9,4 +10,14 @@ from .cfg_fast_soot import CFGFastSoot
 # things to make your life easier
 from .cfg_arch_options import CFGArchOptions
 from .cfg_base import CFGBase
-from ...knowledge_plugins.cfg import CFGNode
+
+
+__all__ = (
+    "CFGFast",
+    "CFGEmulated",
+    "CFG",
+    "CFBlanket",
+    "CFGFastSoot",
+    "CFGArchOptions",
+    "CFGBase",
+)

angr/analyses/cfg/cfb.py

@@ -9,8 +9,8 @@ from cle.backends.tls.elf_tls import ELFTLSObject
 
 from sortedcontainers import SortedDict
 
-from ...knowledge_plugins.cfg.memory_data import MemoryDataSort, MemoryData
-from ..analysis import Analysis
+from angr.knowledge_plugins.cfg.memory_data import MemoryDataSort, MemoryData
+from angr.analyses.analysis import Analysis
 
 _l = logging.getLogger(name=__name__)
 

angr/analyses/cfg/cfg.py

@@ -61,7 +61,7 @@ class CFG(CFGFast):  # pylint: disable=abstract-method
         # Sanity check to make sure the user only wants to use CFGFast
 
         for p in cfgemulated_params:
-            if kwargs.get(p, None) is not None:
+            if kwargs.get(p) is not None:
                 sys.stderr.write(outdated_message + "\n")
                 raise OutdatedError(outdated_exception)