angr 9.2.131__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

angr/exploration_techniques/__init__.py

@@ -1,129 +1,6 @@
-# pylint:disable=unused-import,missing-class-docstring,wrong-import-position
 from __future__ import annotations
-import angr  # For type annotations
-
-
-class ExplorationTechnique:
-    """
-    An otiegnqwvk is a set of hooks for a simulation manager that assists in the implementation of new techniques in
-    symbolic exploration.
-
-    TODO: choose actual name for the functionality (techniques? strategies?)
-
-    Any number of these methods may be overridden by a subclass.
-    To use an exploration technique, call ``simgr.use_technique`` with an *instance* of the technique.
-    """
-
-    # this is the master list of hook functinos
-    _hook_list = ("step", "filter", "selector", "step_state", "successors")
-
-    def _get_hooks(self):
-        return {name: getattr(self, name) for name in self._hook_list if self._is_overridden(name)}
-
-    def _is_overridden(self, name):
-        return getattr(self, name).__code__ is not getattr(ExplorationTechnique, name).__code__
-
-    def __init__(self):
-        # this attribute will be set from above by the manager
-        if not hasattr(self, "project"):
-            self.project: angr.project.Project = None
-
-    def setup(self, simgr):
-        """
-        Perform any initialization on this manager you might need to do.
-
-        :param angr.SimulationManager simgr:    The simulation manager to which you have just been added
-        """
-
-    def step(self, simgr, stash="active", **kwargs):  # pylint:disable=no-self-use
-        """
-        Hook the process of stepping a stash forward. Should call ``simgr.step(stash, **kwargs)`` in order to do the
-        actual processing.
-
-        :param angr.SimulationManager simgr:
-        :param str stash:
-        """
-        simgr.step(stash=stash, **kwargs)
-
-    def filter(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
-        """
-        Perform filtering on which stash a state should be inserted into.
-
-        If the state should be filtered, return the name of the stash to move the state to.
-        If you want to modify the state before filtering it, return a tuple of the stash to move the state to and the
-        modified state.
-        To defer to the original categorization procedure, return the result of ``simgr.filter(state, **kwargs)``
-
-        If the user provided a ``filter_func`` in their step or run command, it will appear here.
-
-        :param angr.SimulationManager simgr:
-        :param angr.SimState state:
-        """
-        return simgr.filter(state, **kwargs)
-
-    def selector(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
-        """
-        Determine if a state should participate in the current round of stepping.
-        Return True if the state should be stepped, and False if the state should not be stepped.
-        To defer to the original selection procedure, return the result of ``simgr.selector(state, **kwargs)``.
-
-        If the user provided a ``selector_func`` in their step or run command, it will appear here.
-
-        :param angr.SimulationManager simgr:
-        :param angr.SimState state:
-        """
-        return simgr.selector(state, **kwargs)
-
-    def step_state(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
-        """
-        Determine the categorization of state successors into stashes. The result should be a dict mapping stash names
-        to the list of successor states that fall into that stash, or None as a stash name to use the original stash
-        name.
-
-        If you would like to directly work with a `SimSuccessors` object, you can obtain it with
-        ``simgr.successors(state, **kwargs)``. This is not recommended, as it denies other hooks the opportunity to
-        look at the successors. Therefore, the usual technique is to call ``simgr.step_state(state, **kwargs)`` and
-        then mutate the returned dict before returning it yourself.
-
-        ..note:: This takes precedence over the `filter` hook - `filter` is only applied to states returned from here
-        in the None stash.
-
-        :param angr.SimulationManager simgr:
-        :param angr.SimState state:
-        """
-        return simgr.step_state(state, **kwargs)
-
-    def successors(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
-        """
-        Perform the process of stepping a state forward, returning a SimSuccessors object.
-
-        To defer to the original succession procedure, return the result of ``simgr.successors(state, **kwargs)``.
-        Be careful about not calling this method (e.g. calling ``project.factory.successors`` manually) as it denies
-        other hooks the opportunity to instrument the step. Instead, you can mutate the kwargs for the step before
-        calling the original, and mutate the result before returning it yourself.
-
-        If the user provided a ``successor_func`` in their step or run command, it will appear here.
-
-        :param angr.SimulationManager simgr:
-        :param angr.SimState state:
-        """
-        return simgr.successors(state, **kwargs)
-
-    def complete(self, simgr):  # pylint:disable=no-self-use,unused-argument
-        """
-        Return whether or not this manager has reached a "completed" state, i.e. ``SimulationManager.run()`` should
-        halt.
-
-        This is the one hook which is *not* subject to the nesting rules of hooks.
-        You should *not* call ``simgr.complete``, you should make your own decision and return True or False.
-        Each of the techniques' completion checkers will be called and the final result will be compted with
-        ``simgr.completion_mode``.
-
-        :param angr.SimulationManager simgr:
-        """
-        return False
-
 
+from .base import ExplorationTechnique
 from .slicecutor import Slicecutor
 from .driller_core import DrillerCore
 from .loop_seer import LoopSeer
@@ -149,30 +26,30 @@ from .suggestions import Suggestions
 from .stub_stasher import StubStasher
 
 __all__ = (
-    "ExplorationTechnique",
-    "Slicecutor",
+    "DFS",
+    "Bucketizer",
+    "CallFunctionGoal",
+    "Director",
     "DrillerCore",
-    "LoopSeer",
-    "Tracer",
+    "ExecuteAddressGoal",
+    "ExplorationTechnique",
     "Explorer",
-    "Threading",
-    "DFS",
     "LengthLimiter",
-    "Veritesting",
+    "LocalLoopSeer",
+    "LoopSeer",
+    "ManualMergepoint",
+    "MemoryWatcher",
     "Oppologist",
-    "Director",
-    "ExecuteAddressGoal",
-    "CallFunctionGoal",
+    "Slicecutor",
     "Spiller",
-    "ManualMergepoint",
-    "TechniqueBuilder",
     "StochasticSearch",
-    "UniqueSearch",
+    "StubStasher",
+    "Suggestions",
     "Symbion",
-    "MemoryWatcher",
-    "Bucketizer",
-    "LocalLoopSeer",
+    "TechniqueBuilder",
+    "Threading",
     "Timeout",
-    "Suggestions",
-    "StubStasher",
+    "Tracer",
+    "UniqueSearch",
+    "Veritesting",
 )

angr/exploration_techniques/base.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import angr
+
+
+class ExplorationTechnique:
+    """
+    An ExplorationTechnique is a set of hooks for a simulation manager that
+    assists in the implementation of new techniques in symbolic exploration.
+
+    Any number of these methods may be overridden by a subclass.
+    To use an exploration technique, call ``simgr.use_technique`` with an
+    *instance* of the technique.
+    """
+
+    # this is the master list of hook functinos
+    _hook_list = ("step", "filter", "selector", "step_state", "successors")
+
+    def _get_hooks(self):
+        return {name: getattr(self, name) for name in self._hook_list if self._is_overridden(name)}
+
+    def _is_overridden(self, name):
+        return getattr(self, name).__code__ is not getattr(ExplorationTechnique, name).__code__
+
+    def __init__(self):
+        # this attribute will be set from above by the manager
+        if not hasattr(self, "project"):
+            self.project: angr.Project = None
+
+    def setup(self, simgr):
+        """
+        Perform any initialization on this manager you might need to do.
+
+        :param angr.SimulationManager simgr:    The simulation manager to which you have just been added
+        """
+
+    def step(self, simgr, stash="active", **kwargs):  # pylint:disable=no-self-use
+        """
+        Hook the process of stepping a stash forward. Should call ``simgr.step(stash, **kwargs)`` in order to do the
+        actual processing.
+
+        :param angr.SimulationManager simgr:
+        :param str stash:
+        """
+        simgr.step(stash=stash, **kwargs)
+
+    def filter(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
+        """
+        Perform filtering on which stash a state should be inserted into.
+
+        If the state should be filtered, return the name of the stash to move the state to.
+        If you want to modify the state before filtering it, return a tuple of the stash to move the state to and the
+        modified state.
+        To defer to the original categorization procedure, return the result of ``simgr.filter(state, **kwargs)``
+
+        If the user provided a ``filter_func`` in their step or run command, it will appear here.
+
+        :param angr.SimulationManager simgr:
+        :param angr.SimState state:
+        """
+        return simgr.filter(state, **kwargs)
+
+    def selector(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
+        """
+        Determine if a state should participate in the current round of stepping.
+        Return True if the state should be stepped, and False if the state should not be stepped.
+        To defer to the original selection procedure, return the result of ``simgr.selector(state, **kwargs)``.
+
+        If the user provided a ``selector_func`` in their step or run command, it will appear here.
+
+        :param angr.SimulationManager simgr:
+        :param angr.SimState state:
+        """
+        return simgr.selector(state, **kwargs)
+
+    def step_state(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
+        """
+        Determine the categorization of state successors into stashes. The result should be a dict mapping stash names
+        to the list of successor states that fall into that stash, or None as a stash name to use the original stash
+        name.
+
+        If you would like to directly work with a `SimSuccessors` object, you can obtain it with
+        ``simgr.successors(state, **kwargs)``. This is not recommended, as it denies other hooks the opportunity to
+        look at the successors. Therefore, the usual technique is to call ``simgr.step_state(state, **kwargs)`` and
+        then mutate the returned dict before returning it yourself.
+
+        ..note:: This takes precedence over the `filter` hook - `filter` is only applied to states returned from here
+        in the None stash.
+
+        :param angr.SimulationManager simgr:
+        :param angr.SimState state:
+        """
+        return simgr.step_state(state, **kwargs)
+
+    def successors(self, simgr, state, **kwargs):  # pylint:disable=no-self-use
+        """
+        Perform the process of stepping a state forward, returning a SimSuccessors object.
+
+        To defer to the original succession procedure, return the result of ``simgr.successors(state, **kwargs)``.
+        Be careful about not calling this method (e.g. calling ``project.factory.successors`` manually) as it denies
+        other hooks the opportunity to instrument the step. Instead, you can mutate the kwargs for the step before
+        calling the original, and mutate the result before returning it yourself.
+
+        If the user provided a ``successor_func`` in their step or run command, it will appear here.
+
+        :param angr.SimulationManager simgr:
+        :param angr.SimState state:
+        """
+        return simgr.successors(state, **kwargs)
+
+    def complete(self, simgr):  # pylint:disable=no-self-use,unused-argument
+        """
+        Return whether or not this manager has reached a "completed" state, i.e. ``SimulationManager.run()`` should
+        halt.
+
+        This is the one hook which is *not* subject to the nesting rules of hooks.
+        You should *not* call ``simgr.complete``, you should make your own decision and return True or False.
+        Each of the techniques' completion checkers will be called and the final result will be compted with
+        ``simgr.completion_mode``.
+
+        :param angr.SimulationManager simgr:
+        """
+        return False

angr/exploration_techniques/bucketizer.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 import logging
 
 from angr.engines.successors import SimSuccessors
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 _l = logging.getLogger(__name__)
 

angr/exploration_techniques/dfs.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from . import ExplorationTechnique
+
 import random
 
+from .base import ExplorationTechnique
+
 
 class DFS(ExplorationTechnique):
     """

angr/exploration_techniques/director.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 import logging
 from collections import defaultdict
 
-import networkx
-
 import claripy
+import networkx
 
 from angr.sim_type import SimType, SimTypePointer, SimTypeChar, SimTypeString, SimTypeReg
 from angr.calling_conventions import default_cc
 from angr.knowledge_base import KnowledgeBase
 from angr.errors import AngrDirectorError
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 l = logging.getLogger(name=__name__)
 

angr/exploration_techniques/driller_core.py

@@ -4,7 +4,7 @@ from itertools import islice
 
 import claripy
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 
 l = logging.getLogger(name=__name__)

angr/exploration_techniques/explorer.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
+
 import logging
+
 import claripy
 
-from . import ExplorationTechnique
-from .common import condition_to_lambda
 from angr import sim_options
 from angr.state_plugins.sim_event import resource_event
+from .base import ExplorationTechnique
+from .common import condition_to_lambda
 
 l = logging.getLogger(name=__name__)
 

angr/exploration_techniques/lengthlimiter.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import ExplorationTechnique
+
+from .base import ExplorationTechnique
 
 
 class LengthLimiter(ExplorationTechnique):

angr/exploration_techniques/local_loop_seer.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 import logging
 from collections import defaultdict
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 
 l = logging.getLogger(name=__name__)

angr/exploration_techniques/loop_seer.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 import logging
 
-from . import ExplorationTechnique
 from angr.knowledge_base import KnowledgeBase
 from angr.knowledge_plugins.functions import Function
-
+from .base import ExplorationTechnique
 
 l = logging.getLogger(name=__name__)
 
@@ -52,6 +51,10 @@ class LoopSeer(ExplorationTechnique):
         self.limit_concrete_loops = limit_concrete_loops
         self.loops = {}
         self.cut_succs = []
+
+        # Delayed import
+        from angr.analyses.loopfinder import Loop
+
         if type(loops) is Loop:
             loops = [loops]
 
@@ -231,6 +234,3 @@ class LoopSeer(ExplorationTechnique):
             f = func
 
         return f
-
-
-from angr.analyses.loopfinder import Loop

angr/exploration_techniques/manual_mergepoint.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
+
 import logging
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 l = logging.getLogger(name=__name__)
 

angr/exploration_techniques/memory_watcher.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from . import ExplorationTechnique
+
 import psutil
 
+from .base import ExplorationTechnique
+
 
 class MemoryWatcher(ExplorationTechnique):
     """Memory Watcher

angr/exploration_techniques/oppologist.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
-import claripy
 import functools
-
 import logging
 
-l = logging.getLogger(name=__name__)
+import claripy
 
 from angr.errors import AngrError, SimError, SimUnsupportedError, SimCCallError
 from angr import sim_options
 from angr.engines.successors import SimSuccessors
+from .base import ExplorationTechnique
 
-exc_list = (AngrError, SimError, claripy.ClaripyError, TypeError, ValueError, ArithmeticError, MemoryError)
+l = logging.getLogger(name=__name__)
 
-from . import ExplorationTechnique
+exc_list = (AngrError, SimError, claripy.ClaripyError, TypeError, ValueError, ArithmeticError, MemoryError)
 
 
 class Oppologist(ExplorationTechnique):

angr/exploration_techniques/slicecutor.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
-from angr.errors import AngrExitError
-from . import ExplorationTechnique
 
 import logging
 
+from angr.errors import AngrExitError
+from .base import ExplorationTechnique
+
+
 l = logging.getLogger(name=__name__)
 
 

angr/exploration_techniques/spiller.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import contextlib
 import logging
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 
 l = logging.getLogger(name=__name__)

angr/exploration_techniques/stochastic.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+
 import random
 from collections import defaultdict
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 
 class StochasticSearch(ExplorationTechnique):

angr/exploration_techniques/stub_stasher.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import ExplorationTechnique
+
+from .base import ExplorationTechnique
 
 
 class StubStasher(ExplorationTechnique):

angr/exploration_techniques/suggestions.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
+
 import logging
+
 import claripy
 
-from . import ExplorationTechnique
 from angr.misc.ux import once
 from angr.misc.picklable_lock import PicklableLock
 from angr.state_plugins.sim_action import SimActionConstraint
 from angr.state_plugins.sim_action_object import SimActionObject
+from .base import ExplorationTechnique
 
 l = logging.getLogger(__name__)
 

angr/exploration_techniques/symbion.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
+
 import logging
+
+from .base import ExplorationTechnique
 from .common import condition_to_lambda
-from . import ExplorationTechnique
 
 l = logging.getLogger("angr.exploration_techniques.symbion")
 

angr/exploration_techniques/tech_builder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from . import ExplorationTechnique
+
+from .base import ExplorationTechnique
 
 
 class TechniqueBuilder(ExplorationTechnique):

angr/exploration_techniques/threading.py

@@ -1,11 +1,9 @@
-# pylint: disable=cell-var-from-loop
 from __future__ import annotations
+
 import concurrent.futures
 import logging
 
-from . import ExplorationTechnique
-from angr.engines.engine import TLSMixin
-from angr.misc.ux import once
+from .base import ExplorationTechnique
 
 l = logging.getLogger(__name__)
 
@@ -69,10 +67,3 @@ class Threading(ExplorationTechnique):
         error_list = []
         simgr.step(stash=self.local_stash, error_list=error_list, **kwargs)
         return state, error_list, simgr
-
-    def successors(self, simgr, state, engine=None, **kwargs):
-        engine = engine or self.project.factory.default_engine
-        if not isinstance(engine, TLSMixin) and once("tls_engine"):
-            l.error("Using Threading exploration technique but your engine is not thread-safe.")
-            l.error("Do you want to add the TLSMixin to your engine?")
-        return simgr.successors(state, engine=engine, **kwargs)

angr/exploration_techniques/timeout.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-import time
+
 import logging
-from . import ExplorationTechnique
+import time
+
+from .base import ExplorationTechnique
 
 l = logging.getLogger(name=__name__)
 

angr/exploration_techniques/tracer.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+
 import logging
-import cle
+from typing import TYPE_CHECKING
 
 import claripy
+import cle
 from capstone import CS_GRP_CALL, CS_GRP_IRET, CS_GRP_JUMP, CS_GRP_RET
 
-from . import ExplorationTechnique
 from angr import BP_BEFORE, BP_AFTER, sim_options
 from angr.errors import AngrTracerError, SimIRSBNoDecodeError
+from .base import ExplorationTechnique
 
 if TYPE_CHECKING:
     from angr.sim_state import SimState

angr/exploration_techniques/unique.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
-from difflib import SequenceMatcher
+
 from collections import Counter
+from difflib import SequenceMatcher
 
-from . import ExplorationTechnique
+from .base import ExplorationTechnique
 
 
 class UniqueSearch(ExplorationTechnique):

angr/exploration_techniques/veritesting.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
-from . import ExplorationTechnique
 
 from angr.sim_options import EFFICIENT_STATE_MERGING
+from .base import ExplorationTechnique
 
 
 class Veritesting(ExplorationTechnique):