angr 9.2.103__py3-none-macosx_11_0_arm64.whl

angr/misc/import_hooks.py

@@ -0,0 +1,63 @@
+# pylint:disable=import-outside-toplevel
+import os.path
+import sys
+import importlib.util
+from importlib.machinery import ModuleSpec
+
+
+class FastPkgResources:
+    """
+    A class that replaces pkg_resources. It only implements resource_filename() and forwards all unimplemented
+    attributes to the original pkg_resources.
+    """
+
+    def __getattribute__(self, name):
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            # fallback to the real pkg_resources
+            remove_fake_pkg_resources()
+            import pkg_resources
+
+            return getattr(pkg_resources, name)
+
+    @staticmethod
+    def __spec__():
+        return ModuleSpec("pkg_resources", None)
+
+    def resource_filename(self, package, resource_name):
+        r = self._resource_filename(package, resource_name)
+        if r is None:
+            # fallback to the real pkg_resources
+            remove_fake_pkg_resources()
+            import pkg_resources
+
+            return pkg_resources.resource_filename(package, resource_name)
+        return r
+
+    @staticmethod
+    def _resource_filename(package, resource_name):
+        spec = importlib.util.find_spec(package)
+        if spec is None:
+            return None
+        if not spec.origin:
+            return None
+        if os.path.isfile(spec.origin):
+            # get the directory
+            base_dir = os.path.dirname(spec.origin)
+        else:
+            base_dir = spec.origin
+        resource_path = os.path.join(base_dir, resource_name)
+        if os.path.exists(resource_path):
+            return resource_path
+        return None
+
+
+def import_fake_pkg_resources(force=False):
+    if force or "pkg_resources" not in sys.modules:
+        sys.modules["pkg_resources"] = FastPkgResources()
+
+
+def remove_fake_pkg_resources():
+    if isinstance(sys.modules.get("pkg_resources", None), FastPkgResources):
+        sys.modules.pop("pkg_resources")

angr/misc/loggers.py

@@ -0,0 +1,130 @@
+import traceback
+import logging
+import zlib
+
+from .ansi import Color, BackgroundColor, color, clear
+
+from .testing import is_testing
+from ..utils.formatting import ansi_color_enabled
+
+
+class Loggers:
+    """
+    Implements a loggers manager for angr.
+    """
+
+    __slots__ = (
+        "default_level",
+        "_loggers",
+        "profiling_enabled",
+        "handler",
+    )
+
+    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]
+        else:
+            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 .. 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,45 @@
+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,291 @@
+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:
+            raise AttributeError(name)
+
+    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):
+                raise AngrNoPluginError("There is no preset named %s" % preset)
+
+        elif not isinstance(preset, PluginPreset):
+            raise ValueError("Argument must be an instance of PluginPreset: %s" % 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]
+
+        elif 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
+
+        else:
+            raise AngrNoPluginError("No such plugin: %s" % 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:
+            raise AngrNoPluginError("There is no plugin named %s" % name)
+
+    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 instanciating 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/range.py

@@ -0,0 +1,21 @@
+class IRange:
+    """
+    A simple range object for testing inclusion. Like range but works for huge numbers.
+    """
+
+    __slots__ = ("start", "end")
+
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+    def __contains__(self, k):
+        if type(k) is int:
+            return k >= self.start and k < self.end
+        return False
+
+    def __getstate__(self):
+        return self.start, self.end
+
+    def __setstate__(self, state):
+        self.start, self.end = state

angr/misc/testing.py

@@ -0,0 +1,23 @@
+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
+        elif 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 @@
+import warnings
+
+
+once_set = set()
+
+
+def once(key):
+    if key in once_set:
+        return False
+    else:
+        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("Don't use %s" % (func.__name__), DeprecationWarning)
+                else:
+                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning)
+                already_complained.add(func)
+            return func(*args, **kwargs)
+
+        return inner
+
+    return outer

angr/misc/weakpatch.py

@@ -0,0 +1,58 @@
+from weakref import WeakValueDictionary, WeakKeyDictionary, _IterationGuard
+
+
+def copy_wvd(self):
+    if self._pending_removals:
+        self._commit_removals()
+    new = WeakValueDictionary()
+    with _IterationGuard(self):
+        for key, wr in self.data.items():
+            o = wr()
+            if o is not None:
+                new[key] = o
+    return new
+
+
+def deepcopy_wvd(self, memo):
+    from copy import deepcopy
+
+    if self._pending_removals:
+        self._commit_removals()
+    new = self.__class__()
+    with _IterationGuard(self):
+        for key, wr in self.data.items():
+            o = wr()
+            if o is not None:
+                new[deepcopy(key, memo)] = o
+    return new
+
+
+def copy_wkd(self):
+    new = WeakKeyDictionary()
+    with _IterationGuard(self):
+        for key, value in self.data.items():
+            o = key()
+            if o is not None:
+                new[o] = value
+    return new
+
+
+def deepcopy_wkd(self, memo):
+    from copy import deepcopy
+
+    new = self.__class__()
+    with _IterationGuard(self):
+        for key, value in self.data.items():
+            o = key()
+            if o is not None:
+                new[o] = deepcopy(value, memo)
+    return new
+
+
+WeakValueDictionary.copy = copy_wvd
+WeakValueDictionary.__copy__ = copy_wvd
+WeakValueDictionary.__deepcopy__ = deepcopy_wvd
+
+WeakKeyDictionary.copy = copy_wkd
+WeakKeyDictionary.__copy__ = copy_wkd
+WeakKeyDictionary.__deepcopy__ = deepcopy_wkd

angr/procedures/__init__.py

@@ -0,0 +1,2 @@
+from .procedure_dict import SIM_PROCEDURES, SimProcedures
+from .definitions import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS

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,10 @@
+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