angr 9.2.117__py3-none-manylinux2014_x86_64.whl → 9.2.118__py3-none-manylinux2014_x86_64.whl

angr/state_plugins/posix.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -16,12 +17,11 @@ class PosixDevFS(SimMount):  # this'll be mounted at /dev
     def get(self, path):  # pylint: disable=arguments-differ
         if path == ["stdin"]:
             return self.state.posix.fd.get(0, None)
-        elif path == ["stdout"]:
+        if path == ["stdout"]:
             return self.state.posix.fd.get(1, None)
-        elif path == ["stderr"]:
+        if path == ["stderr"]:
             return self.state.posix.fd.get(2, None)
-        else:
-            return None
+        return None
 
     def insert(self, path, simfile):  # pylint: disable=unused-argument, arguments-differ
         return False
@@ -50,8 +50,7 @@ class PosixProcFS(SimMount):
     def get(self, path):  # pylint: disable=arguments-differ
         if path == [b"uptime"]:
             return SimFile(b"uptime", content=b"0 0")
-        else:
-            return None
+        return None
 
     def insert(self, path, simfile):  # pylint: disable=unused-argument, arguments-differ
         return False
@@ -301,7 +300,7 @@ class SimSystemPosix(SimStatePlugin):
                 sock_pair[1].set_state(state)
 
     def _pick_fd(self):
-        for fd in range(0, max_fds):
+        for fd in range(max_fds):
             if fd not in self.fd:
                 return fd
         raise SimPosixError("exhausted file descriptors")
@@ -330,10 +329,7 @@ class SimSystemPosix(SimStatePlugin):
             return -1
 
         # TODO: speed this up (editor's note: ...really? this is fine)
-        if preferred_fd is not None and preferred_fd not in self.fd:
-            fd = preferred_fd
-        else:
-            fd = self._pick_fd()
+        fd = preferred_fd if preferred_fd is not None and preferred_fd not in self.fd else self._pick_fd()
 
         flags = self.state.solver.eval(flags)
         create_file = (flags & Flags.O_ACCMODE) in (Flags.O_RDWR, Flags.O_WRONLY)
@@ -344,7 +340,7 @@ class SimSystemPosix(SimStatePlugin):
             if not create_file:
                 if options.ALL_FILES_EXIST not in self.state.options:
                     if options.ANY_FILE_MIGHT_EXIST in self.state.options:
-                        file_exists = claripy.BoolS("file_exists_%s" % ident, explicit_name=True)
+                        file_exists = claripy.BoolS(f"file_exists_{ident}", explicit_name=True)
                     else:
                         return -1
                 else:
@@ -356,7 +352,7 @@ class SimSystemPosix(SimStatePlugin):
                     name,
                     ident=ident,
                     size=self.state.solver.BVS(
-                        "filesize_%s" % ident, self.state.arch.bits, key=("file", ident, "filesize"), eternal=True
+                        f"filesize_{ident}", self.state.arch.bits, key=("file", ident, "filesize"), eternal=True
                     ),
                     file_exists=file_exists,
                 )
@@ -370,9 +366,8 @@ class SimSystemPosix(SimStatePlugin):
         self.fd[fd] = simfd
         if self.state.solver.is_true(simfd.file_exists):
             return fd
-        else:
-            m1 = claripy.BVV(-1, self.state.arch.sizeof["int"])
-            return claripy.If(simfd.file_exists, fd, m1)
+        m1 = claripy.BVV(-1, self.state.arch.sizeof["int"])
+        return claripy.If(simfd.file_exists, fd, m1)
 
     def open_socket(self, ident):
         fd = self._pick_fd()
@@ -398,8 +393,8 @@ class SimSystemPosix(SimStatePlugin):
                     sockpair = sockpair[0].copy(memo), sockpair[1].copy(memo)
 
             if sockpair is None:
-                read_file = SimPacketsStream("socket %s read" % str(ident))
-                write_file = SimPacketsStream("socket %s write" % str(ident))
+                read_file = SimPacketsStream(f"socket {ident!s} read")
+                write_file = SimPacketsStream(f"socket {ident!s} write")
                 sockpair = (read_file, write_file)
 
             self.sockets[ident] = sockpair
@@ -444,10 +439,7 @@ class SimSystemPosix(SimStatePlugin):
 
         new_filename = b"/tmp/angr_implicit_%d" % self.autotmp_counter
         self.autotmp_counter += 1
-        if create_file:
-            flags = Flags.O_RDWR
-        else:
-            flags = Flags.O_RDONLY
+        flags = Flags.O_RDWR if create_file else Flags.O_RDONLY
         concr_fd = self._pick_fd()
         if not self.state.satisfiable(extra_constraints=(concr_fd == fd,)):
             l.error("Could not look up a partially constrained symbolic fd")

angr/state_plugins/preconstrainer.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -57,7 +58,7 @@ class SimStatePreconstrainer(SimStatePlugin):
         elif value.op != "BVV":
             raise ValueError("Passed a value to preconstrain that was not a BVV or a string")
 
-        if variable.op not in claripy.operations.leaf_operations:
+        if not variable.is_leaf():
             l.warning(
                 "The variable %s to preconstrain is not a leaf AST. This may cause replacement failures in the "
                 "claripy replacement backend.",

angr/state_plugins/scratch.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -75,7 +76,7 @@ class SimStateScratch(SimStatePlugin):
 
             self.statement_offset = scratch.statement_offset
 
-        # priveleges
+        # privileges
         self._priv_stack = [False]
 
     @property
@@ -109,13 +110,13 @@ class SimStateScratch(SimStatePlugin):
                 raise SimMissingTempError(
                     "VEX temp variable %d does not exist. This is usually the result of an incorrect slicing." % tmp
                 )
-        except IndexError:
-            raise SimMissingTempError("Accessing a temp that is illegal in this tyenv")
+        except IndexError as err:
+            raise SimMissingTempError("Accessing a temp that is illegal in this tyenv") from err
         self.state._inspect("tmp_read", BP_AFTER, tmp_read_expr=v)
         return v
 
     # pylint:disable=unused-argument
-    def store_tmp(self, tmp, content, reg_deps=None, tmp_deps=None, deps=None, **kwargs):
+    def store_tmp(self, tmp, content, reg_deps=frozenset(), tmp_deps=frozenset(), deps=None, **kwargs):
         """
         Stores a Claripy expression in a VEX temp value.
         If in symbolic mode, this involves adding a constraint for the tmp's symbolic variable.

angr/state_plugins/sim_action.py

@@ -1,4 +1,5 @@
 # This module contains data structures for handling memory, code, and register references.
+from __future__ import annotations
 
 import logging
 
@@ -7,6 +8,7 @@ l = logging.getLogger(name=__name__)
 _noneset = frozenset()
 
 from .sim_event import SimEvent
+import contextlib
 
 
 class SimAction(SimEvent):
@@ -34,40 +36,38 @@ class SimAction(SimEvent):
 
     def __repr__(self):
         if self.sim_procedure is not None:
-            location = "%s()" % self.sim_procedure.display_name
+            location = f"{self.sim_procedure.display_name}()"
         else:
             if self.stmt_idx is not None:
                 location = "0x%x:%d" % (self.ins_addr, self.stmt_idx)  # TODO: Revert this!
             else:
-                location = "0x%x" % self.bbl_addr
+                location = f"0x{self.bbl_addr:x}"
         return f"<{self.__class__.__name__} {location} {self._desc()}>"
 
     def _desc(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @staticmethod
     def _make_object(v):
         if v is None:
             return None
-        elif isinstance(v, SimActionObject):
+        if isinstance(v, SimActionObject):
             return v
-        else:
-            return SimActionObject(v, reg_deps=None, tmp_deps=None)
+        return SimActionObject(v)
 
     @staticmethod
     def _copy_object(v):
         if isinstance(v, SimActionObject):
             return v.copy()
-        else:
-            return None
+        return None
 
     @property
     def all_objects(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def is_symbolic(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def tmp_deps(self):
@@ -78,7 +78,7 @@ class SimAction(SimEvent):
         return frozenset.union(*[v.reg_deps for v in self.all_objects])
 
     def _copy_objects(self, c):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def copy(self):
         c = self._copy_event()
@@ -90,7 +90,6 @@ class SimAction(SimEvent):
         """
         Clears some low-level details (that take up memory) out of the SimAction.
         """
-        pass
 
 
 class SimActionExit(SimAction):
@@ -154,7 +153,7 @@ class SimActionConstraint(SimAction):
         c.condition = self._copy_object(self.condition)
 
     def _desc(self):
-        s = "%s" % str(self.constraint)
+        s = f"{self.constraint!s}"
         if self.condition is not None:
             s += " (cond)"
         return s
@@ -187,7 +186,7 @@ class SimActionOperation(SimAction):
         c.result = self.result
 
     def _desc(self):
-        return "operation/%s" % (self.op)
+        return f"operation/{self.op}"
 
 
 class SimActionData(SimAction):
@@ -278,10 +277,8 @@ class SimActionData(SimAction):
         def _repr(o):
             if type(o) in {bytes, str, int}:
                 return o
-            try:
+            with contextlib.suppress(AttributeError):
                 o = o.ast
-            except AttributeError:
-                pass
             if type(o) in {bytes, str, int}:
                 return o
             return o.shallow_repr()
@@ -301,10 +298,8 @@ class SimActionData(SimAction):
         def _repr(o):
             if type(o) in {bytes, str, int}:
                 return o
-            try:
+            with contextlib.suppress(AttributeError):
                 o = o.ast
-            except AttributeError:
-                pass
             if type(o) in {bytes, str, int}:
                 return o
             return o.shallow_repr()

angr/state_plugins/sim_action_object.py

@@ -1,56 +1,52 @@
-import logging
+from __future__ import annotations
 
-l = logging.getLogger(name=__name__)
-
-import claripy
 import functools
+from itertools import chain
+import typing
 
-from .. import sim_options as o
+import claripy
 
-# pylint:disable=unidiomatic-typecheck
+from angr import sim_options as o
+from angr.errors import SimActionError
+from .sim_action import SimActionData, SimActionOperation
+from ..sim_state import SimState
 
-_noneset = frozenset()
+if typing.TYPE_CHECKING:
+    from claripy.annotation import Annotation
+    from claripy.ast.base import ArgType
 
 
 def _raw_ast(a):
-    if type(a) is SimActionObject:
+    if isinstance(a, SimActionObject):
         return a.ast
-    elif type(a) is dict:
-        return {k: _raw_ast(a[k]) for k in a}
-    elif type(a) in (tuple, list, set, frozenset):
+    if isinstance(a, dict):
+        return {k: _raw_ast(v) for k, v in a.items()}
+    if isinstance(a, tuple | list | set | frozenset):
         return type(a)(_raw_ast(b) for b in a)
-    elif type(a) in (zip, filter, map):
+    if isinstance(a, zip | filter | map):
         return (_raw_ast(i) for i in a)
-    else:
-        return a
+    return a
 
 
 def _all_objects(a):
-    if type(a) is SimActionObject:
+    if isinstance(a, SimActionObject):
         yield a
-    elif type(a) is dict:
-        for b in a.values():
-            yield from _all_objects(b)
-    elif type(a) is (tuple, list, set, frozenset):
-        for b in a:
-            yield from _all_objects(b)
-
+    elif isinstance(a, dict):
+        yield from chain(*(_all_objects(b) for b in a.values()))
+    elif isinstance(a, tuple | list | set | frozenset):
+        yield from chain(*(_all_objects(b) for b in a))
 
-def ast_stripping_op(f, *args, **kwargs):
-    new_args = _raw_ast(args)
-    new_kwargs = _raw_ast(kwargs)
-    return f(*new_args, **new_kwargs)
 
+def ast_preserving_op(f, *args):
+    a = f(_raw_ast(*args)) if len(args) else f()
 
-def ast_preserving_op(f, *args, **kwargs):
-    tmp_deps = frozenset.union(_noneset, *(a.tmp_deps for a in _all_objects(args)))
-    reg_deps = frozenset.union(_noneset, *(a.reg_deps for a in _all_objects(args)))
-
-    a = ast_stripping_op(f, *args, **kwargs)
     if isinstance(a, claripy.ast.Base):
+        tmp_deps = frozenset.union(frozenset(), *(a.tmp_deps for a in _all_objects(args)))
+        reg_deps = frozenset.union(frozenset(), *(a.reg_deps for a in _all_objects(args)))
+
         return SimActionObject(a, reg_deps=reg_deps, tmp_deps=tmp_deps)
-    else:
-        return a
+
+    return a
 
 
 def ast_stripping_decorator(f):
@@ -68,24 +64,32 @@ class SimActionObject:
     A SimActionObject tracks an AST and its dependencies.
     """
 
-    def __init__(self, ast, reg_deps=None, tmp_deps=None, deps=None, state=None):
-        if type(ast) is SimActionObject:
+    ast: claripy.ast.Base
+    reg_deps: frozenset[SimActionData | SimActionOperation]
+    tmp_deps: frozenset[SimActionData | SimActionOperation]
+
+    def __init__(
+        self,
+        ast: claripy.ast.Base,
+        reg_deps: frozenset[SimActionData | SimActionOperation] = frozenset(),
+        tmp_deps: frozenset[SimActionData | SimActionOperation] = frozenset(),
+        deps: frozenset = frozenset(),
+        state: SimState | None = None,
+    ):
+        if isinstance(ast, SimActionObject):
             raise SimActionError("SimActionObject inception!!!")
+
         self.ast = ast
-        if deps is not None:
-            if len(deps) == 0 or (state is not None and o.ACTION_DEPS not in state.options):
-                self.reg_deps = _noneset
-                self.tmp_deps = _noneset
-            else:
-                self.reg_deps = frozenset.union(
-                    *[r.reg_deps for r in deps if type(r) in (sim_action.SimActionData, sim_action.SimActionOperation)]
-                )
-                self.tmp_deps = frozenset.union(
-                    *[r.tmp_deps for r in deps if type(r) in (sim_action.SimActionData, sim_action.SimActionOperation)]
-                )
+        if len(deps) != 0 and (state is None or o.ACTION_DEPS in state.options):
+            self.reg_deps = frozenset.union(
+                *[r.reg_deps for r in deps if isinstance(r, SimActionData | SimActionOperation)]
+            )
+            self.tmp_deps = frozenset.union(
+                *[r.tmp_deps for r in deps if isinstance(r, SimActionData | SimActionOperation)]
+            )
         else:
-            self.reg_deps = _noneset if reg_deps is None else reg_deps
-            self.tmp_deps = _noneset if tmp_deps is None else tmp_deps
+            self.reg_deps = reg_deps
+            self.tmp_deps = tmp_deps
 
     def __repr__(self):
         return f"<SAO {self.ast}>"
@@ -96,53 +100,172 @@ class SimActionObject:
     def __setstate__(self, data):
         self.ast, self.reg_deps, self.tmp_deps = data
 
-    def _preserving_unbound(self, f, *args, **kwargs):
-        return ast_preserving_op(f, *((self,) + tuple(args)), **kwargs)
+    def __len__(self) -> int | None:
+        return len(self.ast)
 
-    def _preserving_bound(self, f, *args, **kwargs):  # pylint:disable=no-self-use
-        return ast_preserving_op(f, *args, **kwargs)
+    def __getitem__(self, k: int):
+        return self.ast[k]
 
-    def __getattr__(self, attr):
-        if attr == "__slots__":
-            raise AttributeError("not forwarding __slots__ to AST")
+    def to_claripy(self) -> claripy.ast.Base:
+        return self.ast
 
-        f = getattr(self.ast, attr)
-        if hasattr(f, "__call__"):
-            return functools.partial(self._preserving_bound, f)
-        elif isinstance(f, claripy.ast.Base):
-            return SimActionObject(f, reg_deps=self.reg_deps, tmp_deps=self.tmp_deps)
-        else:
-            return f
+    def copy(self) -> SimActionObject:
+        return SimActionObject(self.ast, self.reg_deps, self.tmp_deps)
 
-    def __len__(self):
-        return len(self.ast)
+    def is_leaf(self) -> bool:
+        return self.ast.is_leaf()
 
-    def to_claripy(self):
-        return self.ast
+    # Forwarding to ast
 
-    def copy(self):
-        return SimActionObject(self.ast, self.reg_deps, self.tmp_deps)
+    @property
+    def op(self) -> str:
+        return self.ast.op
+
+    @property
+    def args(self) -> tuple[ArgType, ...]:
+        return self.ast.args
+
+    @property
+    def length(self) -> int | None:
+        return self.ast.length
+
+    @property
+    def variables(self) -> frozenset[str]:
+        return self.ast.variables
+
+    @property
+    def symbolic(self) -> bool:
+        return self.ast.symbolic
+
+    @property
+    def annotations(self) -> tuple[Annotation, ...]:
+        return self.ast.annotations
+
+    @property
+    def depth(self) -> int:
+        return self.ast.depth
+
+    # Arithmetic operations
+    def __add__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__add__, other)
+
+    def __radd__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__radd__, other)
+
+    def __truediv__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__truediv__, other)
+
+    def __rtruediv__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rtruediv__, other)
+
+    def __floordiv__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__floordiv__, other)
+
+    def __rfloordiv__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rfloordiv__, other)
+
+    def __mul__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__mul__, other)
+
+    def __rmul__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rmul__, other)
+
+    def __sub__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__sub__, other)
+
+    def __rsub__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rsub__, other)
+
+    def __pow__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__pow__, other)
+
+    def __rpow__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rpow__, other)
+
+    def __mod__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__mod__, other)
+
+    def __rmod__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rmod__, other)
+
+    def SDiv(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.SDiv, other)
+
+    def SMod(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.SMod, other)
+
+    def __neg__(self) -> SimActionObject:
+        return ast_preserving_op(self.ast.__neg__)
+
+    def __abs__(self) -> SimActionObject:
+        return ast_preserving_op(self.ast.__abs__)
+
+    # Comparison -> SimActionObjects
+    def __eq__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__eq__, other)
+
+    def __ne__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__ne__, other)
+
+    def __ge__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__ge__, other)
+
+    def __le__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__le__, other)
+
+    def __gt__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__gt__, other)
+
+    def __lt__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__lt__, other)
+
+    # Bitwise operations
+    def __invert__(self) -> SimActionObject:
+        return ast_preserving_op(self.ast.__invert__)
+
+    def __or__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__or__, other)
+
+    def __ror__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__ror__, other)
+
+    def __and__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__and__, other)
+
+    def __rand__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rand__, other)
+
+    def __xor__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__xor__, other)
 
+    def __rxor__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rxor__, other)
 
-#
-# Overload the operators
-#
+    def __lshift__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__lshift__, other)
 
+    def __rlshift__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rlshift__, other)
 
-def _operator(cls, op_name):
-    def wrapper(self, *args, **kwargs):
-        return self._preserving_unbound(getattr(self.ast.__class__, op_name), *args, **kwargs)
+    def __rshift__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rshift__, other)
 
-    wrapper.__name__ = op_name
-    setattr(cls, op_name, wrapper)
+    def __rrshift__(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.__rrshift__, other)
 
+    # Set operations
+    def union(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.union, other)
 
-def make_methods():
-    for name in claripy.operations.expression_operations | {"__getitem__"}:
-        _operator(SimActionObject, name)
+    def intersection(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.intersection, other)
 
+    def widen(self, other) -> SimActionObject:
+        return ast_preserving_op(self.ast.widen, other)
 
-make_methods()
+    # Bits-specific methods
+    def raw_to_bv(self) -> SimActionObject:
+        return ast_preserving_op(self.ast.raw_to_bv)
 
-from ..errors import SimActionError
-from . import sim_action
+    def bv_to_fp(self) -> SimActionObject:
+        return ast_preserving_op(self.ast.raw_to_fp)

angr/state_plugins/sim_event.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import traceback
 import itertools