angr 9.2.101__tar.gz → 9.2.103__tar.gz

angr-9.2.103/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: angr
+Version: 9.2.103
+Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
+Home-page: https://github.com/angr/angr
+License: BSD-2-Clause
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: CppHeaderParser
+Requires-Dist: GitPython
+Requires-Dist: ailment==9.2.103
+Requires-Dist: archinfo==9.2.103
+Requires-Dist: cachetools
+Requires-Dist: capstone==5.0.0.post1
+Requires-Dist: cffi>=1.14.0
+Requires-Dist: claripy==9.2.103
+Requires-Dist: cle==9.2.103
+Requires-Dist: dpkt
+Requires-Dist: itanium-demangler
+Requires-Dist: mulpyplexer
+Requires-Dist: nampa
+Requires-Dist: networkx!=2.8.1,>=2.0
+Requires-Dist: protobuf>=3.19.0
+Requires-Dist: psutil
+Requires-Dist: pycparser>=2.18
+Requires-Dist: pyformlang
+Requires-Dist: pyvex==9.2.103
+Requires-Dist: rich>=13.1.0
+Requires-Dist: rpyc
+Requires-Dist: sortedcontainers
+Requires-Dist: sympy
+Requires-Dist: unicorn==2.0.1.post1
+Requires-Dist: unique-log-filter
+Requires-Dist: colorama; platform_system == "Windows"
+Provides-Extra: angrdb
+Requires-Dist: sqlalchemy; extra == "angrdb"
+Provides-Extra: docs
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
+Provides-Extra: pcode
+Requires-Dist: pypcode~=2.1.0; extra == "pcode"
+Provides-Extra: testing
+Requires-Dist: keystone-engine; extra == "testing"
+Requires-Dist: pypcode~=2.1.0; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-split; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: sqlalchemy; extra == "testing"
+
+# 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.103/angr/__init__.py

@@ -0,0 +1,153 @@
+# pylint: disable=wildcard-import
+# pylint: disable=wrong-import-position
+
+__version__ = "9.2.103"
+
+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
+
+# import hook: pkg_resources is too slow to import, but it is used by some other packages that angr depends on. while
+# we upstream our fixes, we replace it with a light-weight solution.
+from .misc.import_hooks import import_fake_pkg_resources
+
+import_fake_pkg_resources(force=False)
+
+# 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 *
+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__ = (
+    "SimProcedure",
+    "SIM_PROCEDURES",
+    "SIM_LIBRARIES",
+    "SIM_TYPE_COLLECTIONS",
+    "sim_options",
+    "options",
+    "BP_BEFORE",
+    "BP_AFTER",
+    "BP_BOTH",
+    "BP_IPDB",
+    "BP_IPYTHON",
+    "BP",
+    "SimStatePlugin",
+    "Project",
+    "load_shellcode",
+    "Blade",
+    "SimOS",
+    "Block",
+    "SimulationManager",
+    "Analysis",
+    "register_analysis",
+    "analyses",
+    "knowledge_plugins",
+    "exploration_techniques",
+    "ExplorationTechnique",
+    "types",
+    "StateHierarchy",
+    "SimState",
+    "engines",
+    "DEFAULT_CC",
+    "default_cc",
+    "SYSCALL_CC",
+    "PointerWrapper",
+    "SimCC",
+    "SimFileBase",
+    "SimFile",
+    "SimPackets",
+    "SimFileStream",
+    "SimPacketsStream",
+    "SimFileDescriptor",
+    "SimFileDescriptorDuplex",
+    "SimMount",
+    "SimHostFilesystem",
+    "SimHeapBrk",
+    "SimHeapPTMalloc",
+    "PTChunk",
+    "concretization_strategies",
+    "Server",
+    "manager",
+    "SimProcedures",
+    "KnowledgeBase",
+)

angr-9.2.103/angr/analyses/analysis.py

@@ -0,0 +1,359 @@
+# ruff: noqa: F401
+import functools
+import sys
+import contextlib
+from collections import defaultdict
+from inspect import Signature
+from typing import TYPE_CHECKING, TypeVar, Type, Generic, Optional
+from collections.abc import Callable
+
+import logging
+import time
+import typing
+
+from rich import progress
+
+from ..misc.plugins import PluginVendor, VendorPreset
+from ..misc.ux import deprecated
+
+if TYPE_CHECKING:
+    from ..knowledge_base import KnowledgeBase
+    from ..project import Project
+    from typing_extensions import ParamSpec
+    from .identifier import Identifier
+    from .callee_cleanup_finder import CalleeCleanupFinder
+    from .vsa_ddg import VSA_DDG
+    from .cdg import CDG
+    from .bindiff import BinDiff
+    from .cfg import CFGEmulated
+    from .cfg import CFBlanket
+    from .cfg import CFG
+    from .cfg import CFGFast
+    from .static_hooker import StaticHooker
+    from .ddg import DDG
+    from .congruency_check import CongruencyCheck
+    from .reassembler import Reassembler
+    from .backward_slice import BackwardSlice
+    from .binary_optimizer import BinaryOptimizer
+    from .vfg import VFG
+    from .loopfinder import LoopFinder
+    from .disassembly import Disassembly
+    from .veritesting import Veritesting
+    from .code_tagging import CodeTagging
+    from .boyscout import BoyScout
+    from .variable_recovery import VariableRecoveryFast
+    from .variable_recovery import VariableRecovery
+    from .reaching_definitions import ReachingDefinitionsAnalysis
+    from .complete_calling_conventions import CompleteCallingConventionsAnalysis
+    from .decompiler.clinic import Clinic
+    from .propagator import PropagatorAnalysis
+    from .calling_convention import CallingConventionAnalysis
+    from .decompiler.decompiler import Decompiler
+    from .xrefs import XRefsAnalysis
+
+    AnalysisParams = ParamSpec("AnalysisParams")
+
+l = logging.getLogger(name=__name__)
+
+
+class AnalysisLogEntry:
+    def __init__(self, message, exc_info=False):
+        if exc_info:
+            (e_type, value, traceback) = sys.exc_info()
+            self.exc_type = e_type
+            self.exc_value = value
+            self.exc_traceback = traceback
+        else:
+            self.exc_type = None
+            self.exc_value = None
+            self.exc_traceback = None
+
+        self.message = message
+
+    def __getstate__(self):
+        return (
+            str(self.__dict__.get("exc_type")),
+            str(self.__dict__.get("exc_value")),
+            str(self.__dict__.get("exc_traceback")),
+            self.message,
+        )
+
+    def __setstate__(self, s):
+        self.exc_type, self.exc_value, self.exc_traceback, self.message = s
+
+    def __repr__(self):
+        if self.exc_type is None:
+            msg_str = repr(self.message)
+            if len(msg_str) > 70:
+                msg_str = msg_str[:66] + "..."
+                if msg_str[0] in ('"', "'"):
+                    msg_str += msg_str[0]
+            return "<AnalysisLogEntry %s>" % msg_str
+        else:
+            msg_str = repr(self.message)
+            if len(msg_str) > 40:
+                msg_str = msg_str[:36] + "..."
+                if msg_str[0] in ('"', "'"):
+                    msg_str += msg_str[0]
+            return f"<AnalysisLogEntry {msg_str} with {self.exc_type.__name__}: {self.exc_value}>"
+
+
+A = TypeVar("A", bound="Analysis")
+
+
+class AnalysesHub(PluginVendor[A]):
+    """
+    This class contains functions for all the registered and runnable analyses,
+    """
+
+    def __init__(self, project):
+        super().__init__()
+        self.project = project
+
+    @deprecated()
+    def reload_analyses(self):  # pylint: disable=no-self-use
+        return
+
+    def _init_plugin(self, plugin_cls: type[A]) -> "AnalysisFactory[A]":
+        return AnalysisFactory(self.project, plugin_cls)
+
+    def __getstate__(self):
+        s = super().__getstate__()
+        return (s, self.project)
+
+    def __setstate__(self, sd):
+        s, self.project = sd
+        super().__setstate__(s)
+
+    def __getitem__(self, plugin_cls: type[A]) -> "AnalysisFactory[A]":
+        return AnalysisFactory(self.project, plugin_cls)
+
+
+class KnownAnalysesPlugin(typing.Protocol):
+    Identifier: "Type[Identifier]"
+    CalleeCleanupFinder: "Type[CalleeCleanupFinder]"
+    VSA_DDG: "Type[VSA_DDG]"
+    CDG: "Type[CDG]"
+    BinDiff: "Type[BinDiff]"
+    CFGEmulated: "Type[CFGEmulated]"
+    CFB: "Type[CFBlanket]"
+    CFBlanket: "Type[CFBlanket]"
+    CFG: "Type[CFG]"
+    CFGFast: "Type[CFGFast]"
+    StaticHooker: "Type[StaticHooker]"
+    DDG: "Type[DDG]"
+    CongruencyCheck: "Type[CongruencyCheck]"
+    Reassembler: "Type[Reassembler]"
+    BackwardSlice: "Type[BackwardSlice]"
+    BinaryOptimizer: "Type[BinaryOptimizer]"
+    VFG: "Type[VFG]"
+    LoopFinder: "Type[LoopFinder]"
+    Disassembly: "Type[Disassembly]"
+    Veritesting: "Type[Veritesting]"
+    CodeTagging: "Type[CodeTagging]"
+    BoyScout: "Type[BoyScout]"
+    VariableRecoveryFast: "Type[VariableRecoveryFast]"
+    VariableRecovery: "Type[VariableRecovery]"
+    ReachingDefinitions: "Type[ReachingDefinitionsAnalysis]"
+    CompleteCallingConventions: "Type[CompleteCallingConventionsAnalysis]"
+    Clinic: "Type[Clinic]"
+    Propagator: "Type[PropagatorAnalysis]"
+    CallingConvention: "Type[CallingConventionAnalysis]"
+    Decompiler: "Type[Decompiler]"
+    XRefs: "Type[XRefsAnalysis]"
+
+
+class AnalysesHubWithDefault(AnalysesHub, KnownAnalysesPlugin):
+    """
+    This class has type-hinting for all built-in analyses plugin
+    """
+
+
+class AnalysisFactory(Generic[A]):
+    def __init__(self, project: "Project", analysis_cls: type[A]):
+        self._project = project
+        self._analysis_cls = analysis_cls
+        self.__doc__ = ""
+        self.__doc__ += analysis_cls.__doc__ or ""
+        self.__doc__ += analysis_cls.__init__.__doc__ or ""
+        self.__call__.__func__.__signature__ = Signature.from_callable(analysis_cls.__init__)
+
+    def prep(
+        self,
+        fail_fast=False,
+        kb: Optional["KnowledgeBase"] = None,
+        progress_callback: Callable | None = None,
+        show_progressbar: bool = False,
+    ) -> type[A]:
+        @functools.wraps(self._analysis_cls.__init__)
+        def wrapper(*args, **kwargs):
+            oself = object.__new__(self._analysis_cls)
+            oself.named_errors = defaultdict(list)
+            oself.errors = []
+            oself.log = []
+
+            oself._fail_fast = fail_fast
+            oself._name = self._analysis_cls.__name__
+            oself.project = self._project
+            oself.kb = kb or self._project.kb
+            oself._progress_callback = progress_callback
+
+            oself._show_progressbar = show_progressbar
+            oself.__init__(*args, **kwargs)
+            return oself
+
+        return wrapper  # type: ignore
+
+    def __call__(self, *args, **kwargs) -> A:
+        fail_fast = kwargs.pop("fail_fast", False)
+        kb = kwargs.pop("kb", self._project.kb)
+        progress_callback = kwargs.pop("progress_callback", None)
+        show_progressbar = kwargs.pop("show_progressbar", False)
+
+        w = self.prep(
+            fail_fast=fail_fast, kb=kb, progress_callback=progress_callback, show_progressbar=show_progressbar
+        )
+
+        r = w(*args, **kwargs)
+        # clean up so that it's always pickleable
+        r._progressbar = None
+        return r
+
+
+class Analysis:
+    """
+    This class represents an analysis on the program.
+
+    :ivar project:  The project for this analysis.
+    :type project:  angr.Project
+    :ivar KnowledgeBase kb: The knowledgebase object.
+    :ivar _progress_callback: A callback function for receiving the progress of this analysis. It only takes
+                                        one argument, which is a float number from 0.0 to 100.0 indicating the current
+                                        progress.
+    :ivar bool _show_progressbar: If a progressbar should be shown during the analysis. It's independent from
+                                    _progress_callback.
+    :ivar progress.Progress _progressbar: The progress bar object.
+    """
+
+    project: "Project"
+    kb: "KnowledgeBase"
+    _fail_fast: bool
+    _name: str
+    errors = []
+    named_errors = defaultdict(list)
+    _progress_callback = None
+    _show_progressbar = False
+    _progressbar = None
+    _task = None
+
+    _PROGRESS_WIDGETS = [
+        progress.TaskProgressColumn(),
+        progress.BarColumn(),
+        progress.TextColumn("Elapsed Time:"),
+        progress.TimeElapsedColumn(),
+        progress.TextColumn("Time:"),
+        progress.TimeRemainingColumn(),
+        progress.TextColumn("{task.description}"),
+    ]
+
+    @contextlib.contextmanager
+    def _resilience(self, name=None, exception=Exception):
+        try:
+            yield
+        except exception:  # pylint:disable=broad-except
+            if self._fail_fast:
+                raise
+            else:
+                error = AnalysisLogEntry("exception occurred", exc_info=True)
+                l.error("Caught and logged %s with resilience: %s", error.exc_type.__name__, error.exc_value)
+                if name is None:
+                    self.errors.append(error)
+                else:
+                    self.named_errors[name].append(error)
+
+    def _initialize_progressbar(self):
+        """
+        Initialize the progressbar.
+        :return: None
+        """
+
+        self._progressbar = progress.Progress(*self._PROGRESS_WIDGETS)
+        self._task = self._progressbar.add_task(total=100, description="")
+
+        self._progressbar.start()
+
+    def _update_progress(self, percentage, text=None, **kwargs):
+        """
+        Update the progress with a percentage, including updating the progressbar as well as calling the progress
+        callback.
+
+        :param float percentage:    Percentage of the progressbar. from 0.0 to 100.0.
+        :param kwargs:              Other parameters that will be passed to the progress_callback handler.
+        :return: None
+        """
+
+        if self._show_progressbar:
+            if self._progressbar is None:
+                self._initialize_progressbar()
+
+            self._progressbar.update(self._task, completed=percentage)
+
+        if text is not None and self._progressbar:
+            self._progressbar.update(self._task, description=text)
+
+        if self._progress_callback is not None:
+            self._progress_callback(percentage, text=text, **kwargs)  # pylint:disable=not-callable
+
+    def _finish_progress(self):
+        """
+        Mark the progressbar as finished.
+        :return: None
+        """
+
+        if self._show_progressbar:
+            if self._progressbar is None:
+                self._initialize_progressbar()
+            if self._progressbar is not None:
+                self._progressbar.update(self._task, completed=100)
+                self._progressbar.stop()
+                self._progressbar = None
+
+        if self._progress_callback is not None:
+            self._progress_callback(100.0)  # pylint:disable=not-callable
+
+    @staticmethod
+    def _release_gil(ctr, freq, sleep_time=0.001):
+        """
+        Periodically calls time.sleep() and releases the GIL so other threads (like, GUI threads) have a much better
+        chance to be scheduled, and other critical components (like the GUI) can be kept responsiveness.
+
+        This is, of course, a hack before we move all computational intensive tasks to pure C++ implementations.
+
+        :param int ctr:     A number provided by the caller.
+        :param int freq:    How frequently time.sleep() should be called. time.sleep() is called when ctr % freq == 0.
+        :param sleep_time:  Number (or fraction) of seconds to sleep.
+        :return:            None
+        """
+
+        if ctr != 0 and ctr % freq == 0:
+            time.sleep(sleep_time)
+
+    def __getstate__(self):
+        d = dict(self.__dict__)
+        if "_progressbar" in d:
+            del d["_progressbar"]
+        if "_progress_callback" in d:
+            del d["_progress_callback"]
+        if "_statusbar" in d:
+            del d["_statusbar"]
+        return d
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+    def __repr__(self):
+        return f"<{self._name} Analysis Result at {id(self):#x}>"
+
+
+default_analyses = VendorPreset()
+AnalysesHub.register_preset("default", default_analyses)