angr 9.2.119__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.119"
+__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

@@ -16,13 +16,13 @@ import typing
 
 from rich import progress
 
-from ..misc.plugins import PluginVendor, VendorPreset
-from ..misc.ux import deprecated
-from ..misc import telemetry
+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
@@ -207,7 +207,7 @@ class AnalysisFactory(Generic[A]):
                     listval = list(val)
                     if not listval or (
                         isinstance(listval[0], (str, bytes, bool, int, float))
-                        and all(type(sval) == type(listval[0]) for sval in listval)
+                        and all(type(sval) is type(listval[0]) for sval in listval)
                     ):
                         span.set_attribute(f"arg.{name}", listval)
                 elif isinstance(val, dict):
@@ -215,12 +215,12 @@ class AnalysisFactory(Generic[A]):
                     listval_values = list(val.values())
                     if not listval_keys or (
                         isinstance(listval_keys[0], (str, bytes, bool, int, float))
-                        and all(type(sval) == type(listval_keys[0]) for sval in listval_keys)
+                        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) == type(listval_values[0]) for sval in listval_values)
+                        and all(type(sval) is type(listval_values[0]) for sval in listval_values)
                     ):
                         span.set_attribute(f"arg.{name}.values", listval_values)
                 else:

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)
 

angr/analyses/cfg/cfg_base.py

@@ -748,7 +748,8 @@ class CFGBase(Analysis):
                     # Get all executable sections
                     for section in b.sections:
                         if section.is_executable:
-                            tpl = (section.min_addr, section.max_addr + 1)
+                            max_mapped_addr = section.min_addr + min(section.memsize, section.filesize)
+                            tpl = (section.min_addr, max_mapped_addr)
                             sections.append(tpl)
                     memory_regions += sections
 
@@ -756,7 +757,8 @@ class CFGBase(Analysis):
                 # Get all executable segments
                 for segment in b.segments:
                     if segment.is_executable:
-                        tpl = (segment.min_addr, segment.max_addr + 1)
+                        max_mapped_addr = segment.min_addr + min(segment.memsize, segment.filesize)
+                        tpl = (segment.min_addr, max_mapped_addr)
                         segments.append(tpl)
                 if sections and segments:
                     # are there executable segments with no sections inside?
@@ -770,7 +772,8 @@ class CFGBase(Analysis):
             elif isinstance(b, (Coff, PE)):
                 for section in b.sections:
                     if section.is_executable:
-                        tpl = (section.min_addr, section.max_addr + 1)
+                        max_mapped_addr = section.min_addr + min(section.memsize, section.filesize)
+                        tpl = (section.min_addr, max_mapped_addr)
                         memory_regions.append(tpl)
 
             elif isinstance(b, XBE):
@@ -781,7 +784,7 @@ class CFGBase(Analysis):
                         and not section.is_writable
                         and section.name not in {".data", ".rdata", ".rodata"}
                     ):
-                        tpl = (section.min_addr, section.max_addr + 1)
+                        tpl = (section.min_addr, section.max_addr)
                         memory_regions.append(tpl)
 
             elif isinstance(b, MachO):
@@ -791,7 +794,8 @@ class CFGBase(Analysis):
                         if seg.is_executable:
                             # Take all sections from this segment (MachO style)
                             for section in seg.sections:
-                                tpl = (section.min_addr, section.max_addr + 1)
+                                max_mapped_addr = section.min_addr + min(section.memsize, section.filesize)
+                                tpl = (section.min_addr, max_mapped_addr)
                                 memory_regions.append(tpl)
 
             elif isinstance(b, (Hex, SRec)):
@@ -1313,6 +1317,23 @@ class CFGBase(Analysis):
 
             if new_node is None:
                 # Create a new one
+
+                instruction_addrs = []
+                for ins_addr in n.instruction_addrs:
+                    if n.addr <= ins_addr < n.addr + new_size:
+                        instruction_addrs.append(ins_addr)
+                    elif ins_addr == n.addr + new_size:
+                        break
+                    elif ins_addr > n.addr + new_size:
+                        # the immediate next instruction does not start right after the new node. this means we break
+                        # an existing instruction in the middle! we need to drop the last instruction address from
+                        # instruction_addrs.
+                        instruction_addrs.pop()
+                        break
+                    else:
+                        # should not happen if the instruction_addrs list is normal...
+                        break
+
                 if self.tag == "CFGFast":
                     new_node = CFGNode(
                         n.addr,
@@ -1320,7 +1341,7 @@ class CFGBase(Analysis):
                         self.model,
                         function_address=n.function_address,
                         block_id=n.block_id,
-                        instruction_addrs=[i for i in n.instruction_addrs if n.addr <= i <= n.addr + new_size],
+                        instruction_addrs=instruction_addrs,
                         thumb=n.thumb,
                     )
                 elif self.tag == "CFGEmulated":
@@ -1331,16 +1352,12 @@ class CFGBase(Analysis):
                         callstack_key=callstack_key,
                         function_address=n.function_address,
                         block_id=n.block_id,
-                        instruction_addrs=[i for i in n.instruction_addrs if n.addr <= i <= n.addr + new_size],
+                        instruction_addrs=instruction_addrs,
                         thumb=n.thumb,
                     )
                 else:
                     raise ValueError(f"Unknown tag {self.tag}.")
 
-                # Copy instruction addresses
-                new_node.instruction_addrs = [
-                    ins_addr for ins_addr in n.instruction_addrs if ins_addr < n.addr + new_size
-                ]
                 # Put the new node into end_addresses list
                 if key in smallest_nodes:
                     end_addresses_to_nodes[key].add(smallest_nodes[key])