angr 9.2.192__cp311-cp311-macosx_10_12_x86_64.whl

angr/misc/loggers.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+import traceback
+import logging
+import zlib
+
+from .ansi import Color, BackgroundColor, color, clear
+
+from .testing import is_testing
+from angr.utils.formatting import ansi_color_enabled
+
+
+class Loggers:
+    """
+    Implements a loggers manager for angr.
+    """
+
+    __slots__ = (
+        "_loggers",
+        "default_level",
+        "handler",
+        "profiling_enabled",
+    )
+
+    def __init__(self, default_level=logging.WARNING):
+        self.default_level = default_level
+        self._loggers = {}
+        self.load_all_loggers()
+        self.profiling_enabled = False
+
+        self.handler = logging.StreamHandler()
+        self.handler.setFormatter(CuteFormatter(ansi_color_enabled))
+
+        if not is_testing and len(logging.root.handlers) == 0:
+            self.enable_root_logger()
+            logging.root.setLevel(self.default_level)
+
+    IN_SCOPE = ("angr", "claripy", "cle", "pyvex", "archinfo", "tracer", "driller", "rex", "patcherex", "identifier")
+
+    def load_all_loggers(self):
+        """
+        A dumb and simple way to conveniently aggregate all loggers.
+
+        Adds attributes to this instance of each registered logger, replacing '.' with '_'
+        """
+        for name, logger in logging.Logger.manager.loggerDict.items():
+            if any(name.startswith(x + ".") or name == x for x in self.IN_SCOPE):
+                self._loggers[name] = logger
+
+    def __getattr__(self, k):
+        real_k = k.replace("_", ".")
+        if real_k in self._loggers:
+            return self._loggers[real_k]
+        raise AttributeError(k)
+
+    def __dir__(self):
+        return list(super().__dir__()) + list(self._loggers.keys())
+
+    def enable_root_logger(self):
+        """
+        Enable angr's default logger
+        """
+        logging.root.addHandler(self.handler)
+
+    def disable_root_logger(self):
+        """
+        Disable angr's default logger
+        """
+        logging.root.removeHandler(self.handler)
+
+    @staticmethod
+    def setall(level):
+        for name in logging.Logger.manager.loggerDict:
+            logging.getLogger(name).setLevel(level)
+
+
+class CuteFormatter(logging.Formatter):
+    """
+    A log formatter that can print log messages with colors.
+    """
+
+    __slots__ = ("_should_color",)
+
+    def __init__(self, should_color: bool):
+        super().__init__()
+        self._should_color: bool = should_color
+
+    def format(self, record: logging.LogRecord):
+        name: str = record.name
+        level: str = record.levelname
+        message: str = record.getMessage()
+        name_len: int = len(name)
+        lvl_len: int = len(level)
+        if self._should_color:
+            # Color level
+            if record.levelno >= logging.CRITICAL:
+                level = color(Color.red, True) + level + clear
+                level = color(BackgroundColor.yellow, False) + level + clear
+            elif record.levelno >= logging.ERROR:
+                level = color(Color.red, False) + level + clear
+            elif record.levelno >= logging.WARNING:
+                level = color(Color.yellow, False) + level + clear
+            elif record.levelno >= logging.INFO:
+                level = color(Color.blue, False) + level + clear
+            # Color text
+            c: int = zlib.adler32(record.name.encode()) % 7
+            if c != 0:  # Do not color black or white, allow 'uncolored'
+                col = Color(c + Color.black.value)
+                message = color(col, False) + message + clear
+                name = color(col, False) + name + clear
+        # Finalize log message
+        name = name.ljust(14 + len(name) - name_len)
+        level = level.ljust(8 + len(level) - lvl_len)
+        body: str = f"{level} | {self.formatTime(record, self.datefmt) : <23} | {name} | {message}"
+        if record.exc_info:
+            body += "\n" + "".join(traceback.format_exception(*record.exc_info))[:-1]
+        return body
+
+
+def is_enabled_for(logger, level):
+    if level == 1:
+        from angr import loggers
+
+        return loggers.profiling_enabled
+    return originalIsEnabledFor(logger, level)
+
+
+originalIsEnabledFor = logging.Logger.isEnabledFor
+
+# Override isEnabledFor() for Logger class
+logging.Logger.isEnabledFor = is_enabled_for

angr/misc/picklable_lock.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import threading
+
+
+class PicklableLock:
+    """
+    Normal thread-locks are not pickleable. This provides a pickleable lock by mandating that the lock is unlocked
+    during serialization.
+    """
+
+    _LOCK = threading.Lock
+
+    def __init__(self, *args, **kwargs):
+        self._lock = self.__class__._LOCK(*args, **kwargs)  # pylint: disable=too-many-function-args
+
+    def __enter__(self):
+        return self._lock.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self._lock.__exit__(exc_type, exc_val, exc_tb)
+
+    def acquire(self, *args, **kwargs):
+        return self._lock.acquire(*args, **kwargs)
+
+    def locked(self):
+        return self._lock.locked()
+
+    def release(self):
+        return self._lock.release()
+
+    def __reduce__(self):
+        if self.locked():
+            raise TypeError("Why are you pickling a locked lock")
+        return type(self), ()
+
+
+class PicklableRLock(PicklableLock):
+    """
+    Same as above, but uses RLock instead of Lock for locking. Note that RLock does not provide an interface to tell
+    whether is it presently held by any thread, and thus this class will lie about whether it is locked.
+    """
+
+    _LOCK = threading.RLock
+
+    def locked(self):
+        return False  # ummmmmmmmmmmmmmmm

angr/misc/plugins.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+from typing import TypeVar, Generic
+
+from angr.errors import AngrNoPluginError
+
+import logging
+
+l = logging.getLogger(name=__name__)
+
+P = TypeVar("P")
+
+
+class PluginHub(Generic[P]):
+    """
+    A plugin hub is an object which contains many plugins, as well as the notion of a "preset", or a
+    backer that can provide default implementations of plugins which cater to a certain
+    circumstance.
+
+    Objects in angr like the SimState, the Analyses hub, the SimEngine selector, etc all use this
+    model to unify their mechanisms for automatically collecting and selecting components to use. If
+    you're familiar with design patterns this is a configurable Strategy Pattern.
+
+    Each PluginHub subclass should have a corresponding Plugin subclass, and perhaps a PluginPreset
+    subclass if it wants its presets to be able to specify anything more interesting than a list of
+    defaults.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._active_plugins: dict[str, P] = {}
+        self._active_preset: PluginPreset | None = None
+        self._provided_by_preset: list[int] = []
+
+    #
+    #   Class methods for registration
+    #
+
+    _presets: dict[str, type[P]]
+
+    @classmethod
+    def register_default(cls, name, plugin_cls, preset="default"):
+        if not hasattr(cls, "_presets") or preset not in cls._presets:
+            l.error("Preset %s does not exist yet...", preset)
+            return
+        cls._presets[preset].add_default_plugin(name, plugin_cls)
+
+    @classmethod
+    def register_preset(cls, name, preset):
+        """
+        Register a preset instance with the class of the hub it corresponds to. This allows individual plugin objects to
+        automatically register themselves with a preset by using a classmethod of their own with only the name of the
+        preset to register with.
+        """
+        if not hasattr(cls, "_presets"):
+            cls._presets = {}
+        cls._presets[name] = preset
+
+    #
+    #   Python magic methods
+    #
+
+    def __getstate__(self):
+        return self._active_plugins, self._active_preset, self._provided_by_preset
+
+    def __setstate__(self, s):
+        plugins, preset, provided = s
+        self._active_preset = preset
+        self._active_plugins = {}
+        self._provided_by_preset = provided
+
+        for name, plugin in plugins.items():
+            if name not in self._active_plugins:
+                self.register_plugin(name, plugin)
+
+    def __getattr__(self, name: str) -> P:
+        try:
+            return self.get_plugin(name)
+        except AngrNoPluginError as err:
+            raise AttributeError(name) from err
+
+    def __dir__(self):
+        out = set(self.__dict__)
+        out.update(self._active_plugins)
+        if self.has_plugin_preset:
+            out.update(self._active_preset.list_default_plugins())
+
+        q = [type(self)]
+        while q:
+            cls = q.pop(0)
+            out.update(cls.__dict__)
+            for base in cls.__bases__:
+                if base is not object:
+                    q.append(base)
+
+        return sorted(out)
+
+    #
+    #   Methods for managing the current plugin preset
+    #
+
+    @property
+    def plugin_preset(self):
+        """
+        Get the current active plugin preset
+        """
+        return self._active_preset
+
+    @property
+    def has_plugin_preset(self) -> bool:
+        """
+        Check whether or not there is a plugin preset in use on this hub right now
+        """
+        return self._active_preset is not None
+
+    def use_plugin_preset(self, preset):
+        """
+        Apply a preset to the hub. If there was a previously active preset, discard it.
+
+        Preset can be either the string name of a preset or a PluginPreset instance.
+        """
+        if isinstance(preset, str):
+            try:
+                preset = self._presets[preset]
+            except (AttributeError, KeyError) as err:
+                raise AngrNoPluginError(f"There is no preset named {preset}") from err
+
+        elif not isinstance(preset, PluginPreset):
+            raise ValueError(f"Argument must be an instance of PluginPreset: {preset}")
+
+        if self._active_preset:
+            l.warning("Overriding active preset %s with %s", self._active_preset, preset)
+            self.discard_plugin_preset()
+
+        preset.activate(self)
+        self._active_preset = preset
+
+    def discard_plugin_preset(self):
+        """
+        Discard the current active preset. Will release any active plugins that could have come from the old preset.
+        """
+        if self.has_plugin_preset:
+            for name, plugin in list(self._active_plugins.items()):
+                if id(plugin) in self._provided_by_preset:
+                    self.release_plugin(name)
+            self._active_preset.deactivate(self)
+        self._active_preset = None
+
+    #
+    #   Methods for managing the current active plugins
+    #
+
+    def get_plugin(self, name: str) -> P:
+        """
+        Get the plugin named ``name``. If no such plugin is currently active, try to activate a new
+        one using the current preset.
+        """
+        if name in self._active_plugins:
+            return self._active_plugins[name]
+
+        if self._active_preset is not None:
+            plugin_cls: type[P] = self._active_preset.request_plugin(name)
+            plugin = self._init_plugin(plugin_cls)
+
+            # Remember that this plugin was provided by preset.
+            self._provided_by_preset.append(id(plugin))
+
+            self.register_plugin(name, plugin)
+            return plugin
+
+        raise AngrNoPluginError(f"No such plugin: {name}")
+
+    def _init_plugin(self, plugin_cls: type[P]) -> P:  # pylint: disable=no-self-use
+        """
+        Perform any initialization actions on plugin before it is added to the list of active plugins.
+
+        :param plugin_cls:
+        """
+        return plugin_cls()
+
+    def has_plugin(self, name):
+        """
+        Return whether or not a plugin with the name ``name`` is currently active.
+        """
+        return name in self._active_plugins
+
+    def register_plugin(self, name: str, plugin):
+        """
+        Add a new plugin ``plugin`` with name ``name`` to the active plugins.
+        """
+        if self.has_plugin(name):
+            self.release_plugin(name)
+        self._active_plugins[name] = plugin
+        setattr(self, name, plugin)
+        return plugin
+
+    def release_plugin(self, name):
+        """
+        Deactivate and remove the plugin with name ``name``.
+        """
+        plugin = self._active_plugins[name]
+        if id(plugin) in self._provided_by_preset:
+            self._provided_by_preset.remove(id(plugin))
+
+        del self._active_plugins[name]
+        delattr(self, name)
+
+
+class PluginPreset:
+    """
+    A plugin preset object contains a mapping from name to a plugin class.
+    A preset can be active on a hub, which will cause it to handle requests for plugins which are not already present
+    on the hub.
+
+    Unlike Plugins and PluginHubs, instances of PluginPresets are defined on the module level for individual presets.
+    You should register the preset instance with a hub to allow plugins to easily add themselves to the preset without
+    an explicit reference to the preset itself.
+    """
+
+    def __init__(self):
+        self._default_plugins: dict[str, type[P]] = {}
+
+    def activate(self, hub):  # pylint:disable=no-self-use,unused-argument
+        """
+        This method is called when the preset becomes active on a hub.
+        """
+        return
+
+    def deactivate(self, hub):  # pylint:disable=no-self-use,unused-argument
+        """
+        This method is called when the preset is discarded from the hub.
+        """
+        return
+
+    def add_default_plugin(self, name, plugin_cls):
+        """
+        Add a plugin to the preset.
+        """
+        self._default_plugins[name] = plugin_cls
+
+    def list_default_plugins(self):
+        """
+        Return a list of the names of available default plugins.
+        """
+        return self._default_plugins.keys()
+
+    def request_plugin(self, name: str) -> type[P]:
+        """
+        Return the plugin class which is registered under the name ``name``, or raise NoPlugin if
+        the name isn't available.
+        """
+        try:
+            return self._default_plugins[name]
+        except KeyError as err:
+            raise AngrNoPluginError(f"There is no plugin named {name}") from err
+
+    def copy(self):
+        """
+        Return a copy of self.
+        """
+        cls = self.__class__
+        result = cls.__new__(cls)
+        result._default_plugins = dict(self._default_plugins)  # pylint:disable=protected-access
+        return result
+
+
+class PluginVendor(Generic[P], PluginHub[P]):
+    """
+    A specialized hub which serves only as a plugin vendor, never having any "active" plugins.
+    It will directly return the plugins provided by the preset instead of instantiating them.
+    """
+
+    def release_plugin(self, name):
+        pass
+
+    def register_plugin(self, name, plugin):
+        pass
+
+    def __dir__(self):
+        x = super().__dir__()
+        x.remove("release_plugin")
+        x.remove("register_plugin")
+        x.remove("has_plugin")
+        return x
+
+
+class VendorPreset(PluginPreset):
+    """
+    A specialized preset class for use with the PluginVendor.
+    """

angr/misc/telemetry.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import enum
+
+try:
+    from opentelemetry.trace import get_current_span, Status, StatusCode, Tracer, get_tracer as _get_tracer
+except ImportError:
+    if TYPE_CHECKING:
+        raise
+
+    # pylint: disable=missing-class-docstring,unused-argument
+    class Status:
+        def __init__(self, *args, **kwargs):
+            pass
+
+    class StatusCode(enum.Enum):
+        OK = 0
+        UNSET = 1
+        ERROR = 2
+
+    class Tracer:
+        @staticmethod
+        def start_as_current_span(*args, **kwargs):
+            def inner(f):
+                return f
+
+            return inner
+
+        @staticmethod
+        def get_current_span(*args, **kwargs):
+            return Span()
+
+    def _get_tracer(*args, **kwargs):
+        return Tracer()
+
+    class Span:
+        @staticmethod
+        def set_attribute(*args, **kwargs):
+            pass
+
+        @staticmethod
+        def add_event(*args, **kwargs):
+            pass
+
+    get_current_span = Tracer.get_current_span
+
+
+from angr import __version__
+
+__all__ = ["Status", "StatusCode", "get_current_span", "get_tracer"]
+
+
+def get_tracer(name: str) -> Tracer:
+    return _get_tracer(name, __version__)

angr/misc/testing.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+import sys
+
+TESTER_MODULE_NAMES = ["unittest", "pytest", "_pytest", "nose", "nose2"]
+
+
+def detect_test_env():
+    i = 0
+    while True:
+        i += 1
+        try:
+            frame_module = sys._getframe(i).f_globals.get("__name__")
+        except ValueError:
+            return False
+
+        if frame_module == "__main__" or frame_module == "__console__":
+            return False
+        if frame_module is not None and any(
+            frame_module.startswith(module_name + ".") for module_name in TESTER_MODULE_NAMES
+        ):
+            return True
+
+
+is_testing = detect_test_env()

angr/misc/ux.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+import warnings
+
+
+once_set = set()
+
+
+def once(key):
+    if key in once_set:
+        return False
+    once_set.add(key)
+    return True
+
+
+already_complained = set()
+
+
+def deprecated(replacement=None):
+    def outer(func):
+        def inner(*args, **kwargs):
+            if func not in already_complained:
+                if replacement is None:
+                    warnings.warn(f"Don't use {func.__name__}", DeprecationWarning, stacklevel=2)
+                else:
+                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning, stacklevel=2)
+                already_complained.add(func)
+            return func(*args, **kwargs)
+
+        return inner
+
+    return outer

angr/procedures/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .procedure_dict import SIM_PROCEDURES, SimProcedures
+from .definitions import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
+
+
+__all__ = (
+    "SIM_LIBRARIES",
+    "SIM_PROCEDURES",
+    "SIM_TYPE_COLLECTIONS",
+    "SimProcedures",
+)

angr/procedures/cgc/__init__.py

@@ -0,0 +1,3 @@
+"""
+These procedures implement system calls for the cgc DECREE platform
+"""

angr/procedures/cgc/_terminate.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+import angr
+
+
+class _terminate(angr.SimProcedure):  # pylint:disable=redefined-builtin
+    # pylint:disable=arguments-differ
+
+    NO_RET = True
+
+    def run(self, exit_code):  # pylint:disable=unused-argument
+        return

angr/procedures/cgc/allocate.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+import logging
+
+import claripy
+import angr
+
+l = logging.getLogger(name=__name__)
+
+cgc_flag_page_start_addr = 0x4347C000
+
+
+class allocate(angr.SimProcedure):
+    # pylint:disable=arguments-differ,missing-class-docstring
+
+    def run(self, length, is_x, addr):  # pylint:disable=unused-argument
+        if self.state.solver.symbolic(length):
+            l.warning("Concretizing symbolic length passed to allocate to max_int")
+
+        length = self.state.solver.max_int(length)
+
+        # return code (see allocate() docs)
+        r = claripy.ite_cases(
+            (
+                (length == 0, self.state.cgc.EINVAL),
+                (length > self.state.cgc.max_allocation, self.state.cgc.EINVAL),
+                (self.state.cgc.addr_invalid(addr), self.state.cgc.EFAULT),
+            ),
+            claripy.BVV(0, self.state.arch.bits),
+        )
+
+        if self.state.solver.max_int(r) != 0:
+            # allocate did not succeed. Abort.
+            return r
+
+        aligned_length = ((length + 0xFFF) // 0x1000) * 0x1000
+
+        if isinstance(self.state.cgc.allocation_base, int):
+            self.state.cgc.allocation_base = claripy.BVV(self.state.cgc.allocation_base, self.state.arch.bits)
+
+        chosen = self.state.cgc.get_max_sinkhole(aligned_length)
+        if chosen is None:
+            # No sinkhole that can accommodate the requested size exists
+            chosen = self.state.cgc.allocation_base - aligned_length
+            allocation_base_conc = self.state.solver.eval(self.state.cgc.allocation_base)
+            chosen_conc = self.state.solver.eval(chosen)
+            if chosen_conc <= cgc_flag_page_start_addr < allocation_base_conc:
+                # Chosen memory overlaps with flag page. Add non-overlapping part as a sinkhole and allocate space after
+                # the flag page
+                sinkhole_size = allocation_base_conc - cgc_flag_page_start_addr - 0x1000
+                if sinkhole_size != 0:
+                    self.state.cgc.add_sinkhole(cgc_flag_page_start_addr + 0x1000, sinkhole_size)
+
+                chosen = claripy.BVV(cgc_flag_page_start_addr - aligned_length, self.state.arch.bits)
+            elif chosen_conc <= self.state.project.loader.max_addr < allocation_base_conc:
+                # Chosen memory overlaps with some loaded object
+                sinkhole_size = allocation_base_conc - self.state.project.loader.max_addr
+                if sinkhole_size != 0:
+                    self.state.cgc.add_sinkhole(self.state.project.loader.max_addr, sinkhole_size)
+
+                chosen = claripy.BVV(self.state.project.loader.min_addr - aligned_length, self.state.arch.bits)
+
+            self.state.cgc.allocation_base = chosen
+
+        self.state.memory.store(
+            addr, chosen, size=self.state.arch.bytes, condition=claripy.And(addr != 0), endness="Iend_LE"
+        )
+
+        # PROT_READ | PROT_WRITE default
+        permissions = claripy.BVV(1 | 2, 3)
+        permissions |= claripy.If(is_x != 0, claripy.BVV(4, 3), claripy.BVV(0, 3))
+
+        chosen_conc = self.state.solver.eval(chosen)
+        l.debug("Allocating [%#x, %#x]", chosen_conc, chosen_conc + aligned_length - 1)
+        self.state.memory.map_region(chosen_conc, aligned_length, permissions)
+        return r