angr 9.2.158__tar.gz → 9.2.159__tar.gz

angr-9.2.159/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: angr
+Version: 9.2.159
+Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
+License: BSD-2-Clause
+Project-URL: Homepage, https://angr.io/
+Project-URL: Repository, https://github.com/angr/angr
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cxxheaderparser
+Requires-Dist: GitPython
+Requires-Dist: archinfo==9.2.159
+Requires-Dist: cachetools
+Requires-Dist: capstone==5.0.3
+Requires-Dist: cffi>=1.14.0
+Requires-Dist: claripy==9.2.159
+Requires-Dist: cle==9.2.159
+Requires-Dist: mulpyplexer
+Requires-Dist: networkx!=2.8.1,>=2.0
+Requires-Dist: protobuf>=5.28.2
+Requires-Dist: psutil
+Requires-Dist: pycparser>=2.18
+Requires-Dist: pydemumble
+Requires-Dist: pyformlang
+Requires-Dist: pypcode<4.0,>=3.2.1
+Requires-Dist: pyvex==9.2.159
+Requires-Dist: rich>=13.1.0
+Requires-Dist: sortedcontainers
+Requires-Dist: sympy
+Requires-Dist: typing-extensions
+Requires-Dist: unique-log-filter
+Requires-Dist: colorama; platform_system == "Windows"
+Provides-Extra: angrdb
+Requires-Dist: sqlalchemy; extra == "angrdb"
+Provides-Extra: keystone
+Requires-Dist: keystone-engine; extra == "keystone"
+Provides-Extra: telemetry
+Requires-Dist: opentelemetry-api; extra == "telemetry"
+Provides-Extra: unicorn
+Requires-Dist: unicorn==2.0.1.post1; extra == "unicorn"
+Dynamic: license-file
+
+# angr
+
+[![Latest Release](https://img.shields.io/pypi/v/angr.svg)](https://pypi.python.org/pypi/angr/)
+[![Python Version](https://img.shields.io/pypi/pyversions/angr)](https://pypi.python.org/pypi/angr/)
+[![PyPI Statistics](https://img.shields.io/pypi/dm/angr.svg)](https://pypistats.org/packages/angr)
+[![License](https://img.shields.io/github/license/angr/angr.svg)](https://github.com/angr/angr/blob/master/LICENSE)
+
+angr is a platform-agnostic binary analysis framework.
+It is brought to you by [the Computer Security Lab at UC Santa Barbara](https://seclab.cs.ucsb.edu), [SEFCOM at Arizona State University](https://sefcom.asu.edu), their associated CTF team, [Shellphish](https://shellphish.net), the open source community, and **[@rhelmot](https://github.com/rhelmot)**.
+
+## Project Links
+Homepage: https://angr.io
+
+Project repository: https://github.com/angr/angr
+
+Documentation: https://docs.angr.io
+
+API Documentation: https://api.angr.io/en/latest/
+
+## What is angr?
+
+angr is a suite of Python 3 libraries that let you load a binary and do a lot of cool things to it:
+
+- Disassembly and intermediate-representation lifting
+- Program instrumentation
+- Symbolic execution
+- Control-flow analysis
+- Data-dependency analysis
+- Value-set analysis (VSA)
+- Decompilation
+
+The most common angr operation is loading a binary: `p = angr.Project('/bin/bash')` If you do this in an enhanced REPL like IPython, you can use tab-autocomplete to browse the [top-level-accessible methods](https://docs.angr.io/docs/toplevel) and their docstrings.
+
+The short version of "how to install angr" is `mkvirtualenv --python=$(which python3) angr && python -m pip install angr`.
+
+## Example
+
+angr does a lot of binary analysis stuff.
+To get you started, here's a simple example of using symbolic execution to get a flag in a CTF challenge.
+
+```python
+import angr
+
+project = angr.Project("angr-doc/examples/defcamp_r100/r100", auto_load_libs=False)
+
+@project.hook(0x400844)
+def print_flag(state):
+    print("FLAG SHOULD BE:", state.posix.dumps(0))
+    project.terminate_execution()
+
+project.execute()
+```
+
+# Quick Start
+
+- [Install Instructions](https://docs.angr.io/introductory-errata/install)
+- Documentation as [HTML](https://docs.angr.io/) and sources in the angr [Github repository](https://github.com/angr/angr/tree/master/docs)
+- Dive right in: [top-level-accessible methods](https://docs.angr.io/core-concepts/toplevel)
+- [Examples using angr to solve CTF challenges](https://docs.angr.io/examples).
+- [API Reference](https://angr.io/api-doc/)
+- [awesome-angr repo](https://github.com/degrigis/awesome-angr)

angr-9.2.159/angr/__init__.py

@@ -0,0 +1,363 @@
+# pylint: disable=wildcard-import
+# pylint: disable=wrong-import-position
+from __future__ import annotations
+
+__version__ = "9.2.159"
+
+if bytes is str:
+    raise Exception(
+        """
+
+=-=-=-=-=-=-=-=-=-=-=-=-=  WELCOME TO THE FUTURE!  =-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+angr has transitioned to python 3. Due to the small size of the team behind it,
+we can't reasonably maintain compatibility between both python 2 and python 3.
+If you want to continue using the most recent version of angr (you definitely
+want that, trust us) you should upgrade to python 3. It's like getting your
+vaccinations. It hurts a little bit initially but in the end it's worth it.
+
+For more information, see here: https://docs.angr.io/appendix/migration
+
+Good luck!
+"""
+    )
+
+from .utils.formatting import setup_terminal
+
+setup_terminal()
+del setup_terminal
+
+# let's set up some bootstrap logging
+import logging
+
+logging.getLogger("angr").addHandler(logging.NullHandler())
+from .misc.loggers import Loggers
+
+loggers = Loggers()
+del Loggers
+del logging
+
+# this must happen first, prior to initializing analyses
+from .sim_procedure import SimProcedure
+from .procedures import SIM_PROCEDURES, SimProcedures, SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
+
+from . import sim_options
+
+options = sim_options  # alias
+
+# enums
+from .state_plugins.inspect import BP_BEFORE, BP_AFTER, BP_BOTH, BP_IPDB, BP_IPYTHON
+
+# other stuff
+from .state_plugins.inspect import BP
+from .state_plugins import SimStatePlugin
+
+from .project import Project, load_shellcode
+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
+from .sim_manager import SimulationManager
+from .analyses import Analysis, register_analysis
+from . import analyses
+from . import knowledge_plugins
+from . import exploration_techniques
+from .exploration_techniques import ExplorationTechnique
+from . import sim_type as types
+from .state_hierarchy import StateHierarchy
+
+from .sim_state import SimState
+from . import engines
+from .calling_conventions import default_cc, DEFAULT_CC, SYSCALL_CC, PointerWrapper, SimCC
+from .storage.file import (
+    SimFileBase,
+    SimFile,
+    SimPackets,
+    SimFileStream,
+    SimPacketsStream,
+    SimFileDescriptor,
+    SimFileDescriptorDuplex,
+)
+from .state_plugins.filesystem import SimMount, SimHostFilesystem
+from .state_plugins.heap import SimHeapBrk, SimHeapPTMalloc, PTChunk
+from . import concretization_strategies
+from .distributed import Server
+from .knowledge_base import KnowledgeBase
+from .procedures.definitions import load_external_definitions
+
+# for compatibility reasons
+from . import sim_manager as manager
+
+# now that we have everything loaded, re-grab the list of loggers
+loggers.load_all_loggers()
+
+load_external_definitions()
+
+__all__ = (
+    "BP",
+    "BP_AFTER",
+    "BP_BEFORE",
+    "BP_BOTH",
+    "BP_IPDB",
+    "BP_IPYTHON",
+    "DEFAULT_CC",
+    "SIM_LIBRARIES",
+    "SIM_PROCEDURES",
+    "SIM_TYPE_COLLECTIONS",
+    "SYSCALL_CC",
+    "Analysis",
+    "AngrAnalysisError",
+    "AngrAnnotatedCFGError",
+    "AngrAssemblyError",
+    "AngrBackwardSlicingError",
+    "AngrBladeError",
+    "AngrBladeSimProcError",
+    "AngrCFGError",
+    "AngrCallableError",
+    "AngrCallableMultistateError",
+    "AngrCorruptDBError",
+    "AngrDBError",
+    "AngrDDGError",
+    "AngrDataGraphError",
+    "AngrDecompilationError",
+    "AngrDelayJobNotice",
+    "AngrDirectorError",
+    "AngrError",
+    "AngrExitError",
+    "AngrExplorationTechniqueError",
+    "AngrExplorerError",
+    "AngrForwardAnalysisError",
+    "AngrIncompatibleDBError",
+    "AngrIncongruencyError",
+    "AngrInvalidArgumentError",
+    "AngrJobMergingFailureNotice",
+    "AngrJobWideningFailureNotice",
+    "AngrLifterError",
+    "AngrLoopAnalysisError",
+    "AngrMissingTypeError",
+    "AngrNoPluginError",
+    "AngrPathError",
+    "AngrRuntimeError",
+    "AngrSimOSError",
+    "AngrSkipJobNotice",
+    "AngrSurveyorError",
+    "AngrSyscallError",
+    "AngrTracerError",
+    "AngrTypeError",
+    "AngrUnsupportedSyscallError",
+    "AngrVFGError",
+    "AngrVFGRestartAnalysisNotice",
+    "AngrValueError",
+    "AngrVaultError",
+    "Blade",
+    "Block",
+    "ExplorationTechnique",
+    "KnowledgeBase",
+    "PTChunk",
+    "PathUnreachableError",
+    "PointerWrapper",
+    "Project",
+    "Server",
+    "SimAbstractMemoryError",
+    "SimActionError",
+    "SimCC",
+    "SimCCError",
+    "SimCCallError",
+    "SimConcreteBreakpointError",
+    "SimConcreteMemoryError",
+    "SimConcreteRegisterError",
+    "SimEmptyCallStackError",
+    "SimEngineError",
+    "SimError",
+    "SimEventError",
+    "SimException",
+    "SimExpressionError",
+    "SimFastMemoryError",
+    "SimFastPathError",
+    "SimFile",
+    "SimFileBase",
+    "SimFileDescriptor",
+    "SimFileDescriptorDuplex",
+    "SimFileError",
+    "SimFileStream",
+    "SimFilesystemError",
+    "SimHeapBrk",
+    "SimHeapError",
+    "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",
+    "SimState",
+    "SimStateError",
+    "SimStateOptionsError",
+    "SimStatePlugin",
+    "SimStatementError",
+    "SimSymbolicFilesystemError",
+    "SimTranslationError",
+    "SimUCManagerAllocationError",
+    "SimUCManagerError",
+    "SimUnicornError",
+    "SimUnicornSymbolic",
+    "SimUnicornUnsupport",
+    "SimUninitializedAccessError",
+    "SimUnsatError",
+    "SimUnsupportedError",
+    "SimValueError",
+    "SimZeroDivisionException",
+    "SimulationManager",
+    "SimulationManagerError",
+    "StateHierarchy",
+    "TracerEnvironmentError",
+    "UnsupportedCCallError",
+    "UnsupportedDirtyError",
+    "UnsupportedIRExprError",
+    "UnsupportedIROpError",
+    "UnsupportedIRStmtError",
+    "UnsupportedNodeTypeError",
+    "UnsupportedSyscallError",
+    "analyses",
+    "concretization_strategies",
+    "default_cc",
+    "engines",
+    "exploration_techniques",
+    "knowledge_plugins",
+    "load_shellcode",
+    "manager",
+    "options",
+    "register_analysis",
+    "sim_options",
+    "types",
+)

angr-9.2.159/angr/ailment/__init__.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+import logging
+
+from .block import Block
+from . import statement
+from . import expression
+from .statement import Assignment, Statement
+from .expression import Expression, Const, Tmp, Register, UnaryOp, BinaryOp
+from .converter_common import Converter
+from .manager import Manager
+from .block_walker import AILBlockWalker, AILBlockWalkerBase
+
+log = logging.getLogger(__name__)
+
+# REALLY BAD
+Expr = expression
+Stmt = statement
+
+available_converters: set[str] = set()
+
+try:
+    from .converter_vex import VEXIRSBConverter
+    import pyvex
+
+    available_converters.add("vex")
+except ImportError as e:
+    log.debug("Could not import VEXIRSBConverter")
+    log.debug(e)
+    VEXIRSBConverter = None
+
+try:
+    from .converter_pcode import PCodeIRSBConverter
+    from angr.engines import pcode
+
+    available_converters.add("pcode")
+except ImportError as e:
+    log.debug("Could not import PCodeIRSBConverter")
+    log.debug(e)
+    PCodeIRSBConverter = None
+
+
+class IRSBConverter(Converter):
+    @staticmethod
+    def convert(irsb, manager):  # pylint:disable=arguments-differ
+        """
+        Convert the given IRSB to an AIL block
+
+        :param irsb:    The IRSB to convert
+        :param manager: The manager to use
+        :return:        Returns the converted block
+        """
+
+        if "pcode" in available_converters and isinstance(irsb, pcode.lifter.IRSB):
+            return PCodeIRSBConverter.convert(irsb, manager)
+        if "vex" in available_converters and isinstance(irsb, pyvex.IRSB):
+            return VEXIRSBConverter.convert(irsb, manager)
+        raise ValueError(f"No converter available for {type(irsb)}")
+
+
+__all__ = [
+    "AILBlockWalker",
+    "AILBlockWalkerBase",
+    "Assignment",
+    "BinaryOp",
+    "Block",
+    "Const",
+    "Expr",
+    "Expression",
+    "IRSBConverter",
+    "Manager",
+    "PCodeIRSBConverter",
+    "Register",
+    "Statement",
+    "Stmt",
+    "Tmp",
+    "UnaryOp",
+    "VEXIRSBConverter",
+    "available_converters",
+    "expression",
+    "statement",
+]

angr-9.2.159/angr/ailment/block.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .statement import Statement
+
+
+class Block:
+    """
+    Describes an AIL block.
+    """
+
+    __slots__ = (
+        "_hash",
+        "addr",
+        "idx",
+        "original_size",
+        "statements",
+    )
+
+    def __init__(self, addr: int, original_size, statements=None, idx=None):
+        self.addr = addr
+        self.original_size = original_size
+        self.statements: list[Statement] = [] if statements is None else statements
+        self.idx = idx
+        self._hash = None  # cached hash value
+
+    def copy(self, statements=None):
+        return Block(
+            addr=self.addr,
+            original_size=self.original_size,
+            statements=self.statements[::] if statements is None else statements,
+            idx=self.idx,
+        )
+
+    def __repr__(self):
+        if self.idx is None:
+            return f"<AILBlock {self.addr:#x} of {len(self.statements)} statements>"
+        return f"<AILBlock {self.addr:#x}.{self.idx} of {len(self.statements)} statements>"
+
+    def dbg_repr(self, indent=0):
+        indent_str = " " * indent
+        if self.idx is None:
+            block_str = f"{indent_str}## Block {self.addr:x}\n"
+        else:
+            block_str = f"{indent_str}## Block {self.addr:x}.{self.idx}\n"
+        stmts_str = "\n".join(
+            [
+                (f"{indent_str}{i:02d} | {getattr(stmt, 'ins_addr', 0):#x} | {stmt}")
+                for i, stmt in enumerate(self.statements)
+            ]
+        )
+        block_str += stmts_str + "\n"
+        return block_str
+
+    def __str__(self):
+        return self.dbg_repr()
+
+    def __eq__(self, other):
+        return (
+            type(other) is Block
+            and self.addr == other.addr
+            and self.statements == other.statements
+            and self.idx == other.idx
+        )
+
+    def likes(self, other):
+        return (
+            type(other) is Block
+            and len(self.statements) == len(other.statements)
+            and all(s1.likes(s2) for s1, s2 in zip(self.statements, other.statements))
+        )
+
+    def clear_hash(self):
+        self._hash = None
+
+    def __hash__(self):
+        # Changing statements does not change the hash of a block, which allows in-place statement editing
+        if self._hash is None:
+            self._hash = hash((Block, self.addr, self.idx))
+        return self._hash