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

angr/storage/memory_object.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from ..errors import SimMemoryError
@@ -68,9 +69,13 @@ class SimMemoryObject:
         return self.base + self.length - 1
 
     def concrete_bytes(self, offset: int, size: int) -> bytes | None:
-        if self._concrete_bytes is None:
-            if isinstance(self.object, claripy.ast.Bits) and self.object.op == "BVV" and not self.object.annotations:
-                self._concrete_bytes = self.object.concrete_value.to_bytes(len(self.object) // self._byte_width, "big")
+        if (
+            self._concrete_bytes is None
+            and isinstance(self.object, claripy.ast.Bits)
+            and self.object.op == "BVV"
+            and not self.object.annotations
+        ):
+            self._concrete_bytes = self.object.concrete_value.to_bytes(len(self.object) // self._byte_width, "big")
 
         if self._concrete_bytes is None:
             return None
@@ -95,25 +100,24 @@ class SimMemoryObject:
 
             return o if allow_concrete else claripy.BVV(o)
 
-        else:
-            offset = addr - self.base
-            try:
-                thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
-            except claripy.ClaripyOperationError:
-                # hacks to handle address space wrapping
-                if offset >= 0:
-                    raise
-                if offset + 2**32 >= 0:
-                    offset += 2**32
-                elif offset + 2**64 >= 0:
-                    offset += 2**64
-                else:
-                    raise
-                thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
-
-            if self.endness != endness:
-                thing = thing.reversed
-            return thing
+        offset = addr - self.base
+        try:
+            thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
+        except claripy.ClaripyOperationError:
+            # hacks to handle address space wrapping
+            if offset >= 0:
+                raise
+            if offset + 2**32 >= 0:
+                offset += 2**32
+            elif offset + 2**64 >= 0:
+                offset += 2**64
+            else:
+                raise
+            thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
+
+        if self.endness != endness:
+            thing = thing.reversed
+        return thing
 
     def _object_equals(self, other):
         if self.is_bytes != other.is_bytes:
@@ -121,17 +125,15 @@ class SimMemoryObject:
 
         if self.is_bytes:
             return self.object == other.object
-        else:
-            return self.object.cache_key == other.object.cache_key
+        return self.object.cache_key == other.object.cache_key
 
     def _length_equals(self, other):
-        if type(self.length) is not type(other.length):  # noqa: E721
+        if type(self.length) is not type(other.length):
             return False
 
         if isinstance(self.length, int):
             return self.length == other.length
-        else:
-            return self.length.cache_key == other.length.cache_key
+        return self.length.cache_key == other.length.cache_key
 
     def __eq__(self, other):
         if self is other:
@@ -150,7 +152,7 @@ class SimMemoryObject:
         return not self == other
 
     def __repr__(self):
-        return "MO(%s)" % self.object
+        return f"MO({self.object})"
 
 
 class SimLabeledMemoryObject(SimMemoryObject):

angr/storage/pcap.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import socket
 import logging
 
@@ -19,8 +20,8 @@ class PCAP:
             self.initialize(self.path)
 
     def initialize(self, path):
-        f = open(path)
-        pcap = dpkt.pcap.Reader(f)
+        with open(path) as f:
+            pcap = dpkt.pcap.Reader(f)
         for _, buf in pcap:
             ip = dpkt.ethernet.Ethernet(buf).ip
             tcp = ip.data
@@ -29,7 +30,6 @@ class PCAP:
                 self.out_streams.append((len(tcp.data), tcp.data))
             elif len(tcp.data) != 0:
                 self.in_streams.append((len(tcp.data), tcp.data))
-        f.close()
 
     def recv(self, length):
         temp = 0

angr/tablespecs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 

angr/utils/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .timing import timethis
 from . import graph
 from . import constants

angr/utils/ail.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from ailment import AILBlockWalkerBase
+from ailment.block import Block
+from ailment.expression import Expression, VirtualVariable, Phi
+from ailment.statement import Assignment, Statement
+
+
+def is_phi_assignment(stmt: Statement) -> bool:
+    return isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable) and isinstance(stmt.src, Phi)
+
+
+class HasExprWalker(AILBlockWalkerBase):
+    """
+    Test if any expressions in exprs_to_check is used in another AIL expression.
+    """
+
+    def __init__(self, exprs_to_check: set[Expression]) -> None:
+        super().__init__()
+
+        self.exprs_to_check: set[Expression] = exprs_to_check
+        self.contains_exprs: bool = False
+
+    def _handle_expr(
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
+    ) -> None:
+        if expr in self.exprs_to_check:
+            self.contains_exprs = True
+        if not self.contains_exprs:
+            super()._handle_expr(expr_idx, expr, stmt_idx, stmt, block)

angr/utils/algo.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 from collections.abc import Callable
 

angr/utils/bits.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+
+def truncate_bits(value: int, nbits: int) -> int:
+    """
+    Truncate `value` to `nbits`.
+
+    For example: truncate_bits(0x1234, 8) -> 0x34
+    """
+    if nbits < 0:
+        raise ValueError("nbits must not be negative")
+    return value & (2**nbits - 1)

angr/utils/constants.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 DEFAULT_STATEMENT = -2
 SWITCH_MISSING_DEFAULT_NODE_ADDR = 0xFFFF_FFFE
 MAX_POINTSTO_BITS = -1330 * 8

angr/utils/cowdict.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections import ChainMap
 
 
@@ -26,8 +27,7 @@ class ChainMapCOW(ChainMap):
             ch = self.new_child()
             ch.collapse_threshold = self.collapse_threshold
             return ch
-        else:
-            return self
+        return self
 
 
 class DefaultChainMapCOW(ChainMapCOW):
@@ -60,5 +60,4 @@ class DefaultChainMapCOW(ChainMapCOW):
             r.default_factory = self.default_factory
             r.collapse_threshold = self.collapse_threshold
             return r
-        else:
-            return self
+        return self

angr/utils/dynamic_dictlist.py

@@ -1,13 +1,10 @@
+from __future__ import annotations
 import platform
-from typing import Union, Generic, TypeVar
+from typing import Generic, TypeVar
 
 
 # Ref: https://github.com/angr/angr/pull/3471#issuecomment-1236515950
-if platform.python_implementation() == "PyPy":
-    LIST2DICT_THRESHOLD = 96
-else:
-    # cpython
-    LIST2DICT_THRESHOLD = 2048
+LIST2DICT_THRESHOLD = 96 if platform.python_implementation() == "PyPy" else 2048
 
 
 VT = TypeVar("VT")
@@ -27,7 +24,7 @@ class DynamicDictList(Generic[VT]):
     def __init__(
         self,
         max_size: int | None = None,
-        content: Union["DynamicDictList", dict[int, VT], list[VT]] | None = None,
+        content: DynamicDictList | dict[int, VT] | list[VT] | None = None,
     ):
         self.list_content: list[VT] | None = None
         self.dict_content: dict[int, VT] | None = None

angr/utils/endness.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import Const
 
 

angr/utils/enums_conv.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-member
+from __future__ import annotations
 import logging
 
 l = logging.getLogger(name=__name__)

angr/utils/env.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 

angr/utils/formatting.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 from collections.abc import Sequence, Callable
 

angr/utils/funcid.py

@@ -1,4 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 
 import capstone
 
@@ -31,7 +32,7 @@ def is_function_security_check_cookie(func, project, security_cookie_addr: int)
     return False
 
 
-def is_function_security_init_cookie(func: "Function", project, security_cookie_addr: int | None) -> bool:
+def is_function_security_init_cookie(func: Function, project, security_cookie_addr: int | None) -> bool:
     if func.is_plt or func.is_syscall or func.is_simprocedure:
         return False
     # the function should have only one return point
@@ -74,7 +75,7 @@ def is_function_security_init_cookie(func: "Function", project, security_cookie_
     return False
 
 
-def is_function_security_init_cookie_win8(func: "Function", project, security_cookie_addr: int) -> bool:
+def is_function_security_init_cookie_win8(func: Function, project, security_cookie_addr: int) -> bool:
     # disassemble the first instruction
     if func.is_plt or func.is_syscall or func.is_simprocedure:
         return False
@@ -113,21 +114,21 @@ def is_function_security_init_cookie_win8(func: "Function", project, security_co
     return False
 
 
-def is_function_likely_security_init_cookie(func: "Function") -> bool:
+def is_function_likely_security_init_cookie(func: Function) -> bool:
     """
     Conducts a fuzzy match for security_init_cookie function.
     """
 
     callees = [node for node in func.transition_graph if isinstance(node, Function)]
     callee_names = {callee.name for callee in callees}
-    if callee_names.issuperset(
-        {
-            "GetSystemTimeAsFileTime",
-            "GetCurrentProcessId",
-            "GetCurrentThreadId",
-            "GetTickCount",
-            "QueryPerformanceCounter",
-        }
-    ):
-        return True
-    return False
+    return bool(
+        callee_names.issuperset(
+            {
+                "GetSystemTimeAsFileTime",
+                "GetCurrentProcessId",
+                "GetCurrentThreadId",
+                "GetTickCount",
+                "QueryPerformanceCounter",
+            }
+        )
+    )

angr/utils/graph.py

@@ -1,4 +1,6 @@
-from collections import defaultdict
+from __future__ import annotations
+from typing import Any
+from collections import defaultdict, OrderedDict
 import logging
 
 import networkx
@@ -183,10 +185,7 @@ def dominates(idom, dominator_node, node):
     while n:
         if n == dominator_node:
             return True
-        if n in idom and n != idom[n]:
-            n = idom[n]
-        else:
-            n = None
+        n = idom[n] if n in idom and n != idom[n] else None
     return False
 
 
@@ -256,12 +255,10 @@ class TemporaryNode:
         self._label = label
 
     def __repr__(self):
-        return "TN[%s]" % self._label
+        return f"TN[{self._label}]"
 
     def __eq__(self, other):
-        if isinstance(other, TemporaryNode) and other._label == self._label:
-            return True
-        return False
+        return bool(isinstance(other, TemporaryNode) and other._label == self._label)
 
     def __hash__(self):
         return hash(("TemporaryNode", self._label))
@@ -294,7 +291,7 @@ class ContainerNode:
         return hash(("CN", self._obj))
 
     def __repr__(self):
-        return "CN[%s]" % repr(self._obj)
+        return f"CN[{self._obj!r}]"
 
 
 class Dominators:
@@ -324,7 +321,7 @@ class Dominators:
     def _graph_successors(self, graph, node):
         """
         Return the successors of a node in the graph.
-        This method can be overriden in case there are special requirements with the graph and the successors. For
+        This method can be overridden in case there are special requirements with the graph and the successors. For
         example, when we are dealing with a control flow graph, we may not want to get the FakeRet successors.
 
         :param graph: The graph.
@@ -519,9 +516,8 @@ class Dominators:
     def _pd_eval(self, v):
         if self._ancestor[v.index] is None:
             return v
-        else:
-            self._pd_compress(v)
-            return self._label[v.index]
+        self._pd_compress(v)
+        return self._label[v.index]
 
     def _pd_compress(self, v):
         if self._ancestor[self._ancestor[v.index].index] is not None:
@@ -595,8 +591,7 @@ class GraphUtils:
 
         ordered_merge_points = GraphUtils.quasi_topological_sort_nodes(graph, merge_points)
 
-        addrs = [n.addr for n in ordered_merge_points]
-        return addrs
+        return [n.addr for n in ordered_merge_points]
 
     @staticmethod
     def find_widening_points(function_addr, function_endpoints, graph):  # pylint: disable=unused-argument
@@ -701,7 +696,7 @@ class GraphUtils:
             return src_addr + dst_addr
 
         # collapse all strongly connected components
-        edges = sorted(list(graph.edges()), key=_sort_edge)
+        edges = sorted(graph.edges(), key=_sort_edge)
         for src, dst in edges:
             scc_index = GraphUtils._components_index_node(sccs, src)
             if scc_index is not None:
@@ -741,8 +736,7 @@ class GraphUtils:
             return ordered_nodes
 
         nodes = set(nodes)
-        ordered_nodes = [n for n in ordered_nodes if n in nodes]
-        return ordered_nodes
+        return [n for n in ordered_nodes if n in nodes]
 
     @staticmethod
     def _components_index_node(components, node):
@@ -820,3 +814,42 @@ class GraphUtils:
                                 break
 
         ordered_nodes.extend(GraphUtils.quasi_topological_sort_nodes(subgraph))
+
+    @staticmethod
+    def loop_nesting_forest(graph: networkx.DiGraph, start_node) -> OrderedDict[Any, networkx.DiGraph]:
+        """
+        Generates the loop-nesting forest for the provided directional graph. This is *not* the algorithm proposed by
+        Ramalingam.
+
+        :param graph:       the graph to generate the loop-nesting forest for.
+        :param start_node:  the node to start traversing the graph from.
+        :return:            An ordered dict of loop heads to their corresponding loop nodes.
+        """
+
+        # TODO: Should we replace this function using dfs_back_edges()?
+
+        loop_head_to_loop_nodes = OrderedDict()
+
+        graph_copy = networkx.DiGraph(graph)
+
+        while True:
+            cycles_iter = networkx.simple_cycles(graph_copy)
+            try:
+                cycle = next(cycles_iter)
+            except StopIteration:
+                break
+
+            loop_backedge = (None, None)
+
+            for n in networkx.dfs_preorder_nodes(graph_copy, source=start_node):
+                if n in cycle:
+                    idx = cycle.index(n)
+                    loop_backedge = (cycle[-1], cycle[idx]) if idx == 0 else (cycle[idx - 1], cycle[idx])
+                    break
+
+            loop_head = loop_backedge[1]
+            loop_head_to_loop_nodes[loop_head] = networkx.DiGraph(graph_copy.subgraph(cycle))
+
+            graph_copy.remove_edge(*loop_backedge)
+
+        return loop_head_to_loop_nodes

angr/utils/lazy_import.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import importlib.util
 import sys
 

angr/utils/library.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ..sim_type import (
@@ -46,8 +47,7 @@ def get_function_name(s):
     else:
         raise ValueError("Cannot find any space in the function declaration string.")
 
-    func_name = func_name[pos + 1 :]
-    return func_name
+    return func_name[pos + 1 :]
 
 
 def register_kernel_types():
@@ -72,7 +72,7 @@ def register_kernel_types():
     )
 
 
-def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
+def convert_cproto_to_py(c_decl) -> tuple[str, SimTypeFunction, str]:
     """
     Convert a C-style function declaration string to its corresponding SimTypes-based Python representation.
 
@@ -84,7 +84,7 @@ def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
     s = []
 
     try:
-        s.append("# %s" % c_decl)  # comment string
+        s.append(f"# {c_decl}")  # comment string
 
         parsed = parse_file(c_decl)
         parsed_decl = parsed[0]
@@ -100,7 +100,7 @@ def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
         try:
             func_name = get_function_name(c_decl)
             func_proto = None
-            s.append('"%s": None,' % func_name)
+            s.append(f'"{func_name}": None,')
         except ValueError:
             # Failed to extract the function name. Is it a function declaration?
             func_name, func_proto = None, None
@@ -121,7 +121,7 @@ def convert_cppproto_to_py(
 
     s = []
     try:
-        s.append("# %s" % cpp_decl)
+        s.append(f"# {cpp_decl}")
 
         parsed = parse_cpp_file(cpp_decl, with_param_names=with_param_names)
         parsed_decl = parsed[0]
@@ -136,7 +136,7 @@ def convert_cppproto_to_py(
         try:
             func_name = get_function_name(cpp_decl)
             func_proto = None
-            s.append('"%s": None,' % func_name)
+            s.append(f'"{func_name}": None,')
         except ValueError:
             # Failed to extract the function name. Is it a function declaration?
             func_name, func_proto = None, None
@@ -145,7 +145,7 @@ def convert_cppproto_to_py(
 
 
 def parsedcprotos2py(
-    parsed_cprotos: list[tuple[str, "SimTypeFunction", str]], fd_spots=frozenset(), remove_sys_prefix=False
+    parsed_cprotos: list[tuple[str, SimTypeFunction, str]], fd_spots=frozenset(), remove_sys_prefix=False
 ) -> str:
     """
     Parse a list of C function declarations and output to Python code that can be embedded into
@@ -196,11 +196,8 @@ def cprotos2py(cprotos: list[str], fd_spots=frozenset(), remove_sys_prefix=False
 
 
 def get_cpp_function_name(demangled_name, specialized=True, qualified=True):
-    if not specialized:
-        # remove "<???>"s
-        name = normalize_cpp_function_name(demangled_name)
-    else:
-        name = demangled_name
+    # remove "<???>"s
+    name = normalize_cpp_function_name(demangled_name) if not specialized else demangled_name
 
     if not qualified:
         # remove leading namespaces

angr/utils/loader.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import archinfo
@@ -6,7 +7,7 @@ if TYPE_CHECKING:
     from angr import Project
 
 
-def is_pc(project: "Project", ins_addr: int, addr: int) -> bool:
+def is_pc(project: Project, ins_addr: int, addr: int) -> bool:
     """
     Check if the given address is program counter (PC) or not. This function is for handling the case on some bizarre
     architectures where PC is always the currently executed instruction address plus a constant value.
@@ -21,13 +22,12 @@ def is_pc(project: "Project", ins_addr: int, addr: int) -> bool:
             # thumb mode
             ins_addr = ins_addr - 1
             return addr == ins_addr + 4
-        else:
-            # arm mode
-            return addr == ins_addr + 8
+        # arm mode
+        return addr == ins_addr + 8
     return ins_addr == addr
 
 
-def is_in_readonly_section(project: "Project", addr: int) -> bool:
+def is_in_readonly_section(project: Project, addr: int) -> bool:
     """
     Check if the specified address is inside a read-only section.
 
@@ -41,7 +41,7 @@ def is_in_readonly_section(project: "Project", addr: int) -> bool:
     return False
 
 
-def is_in_readonly_segment(project: "Project", addr: int) -> bool:
+def is_in_readonly_segment(project: Project, addr: int) -> bool:
     """
     Check if the specified address is inside a read-only segment.
 

angr/utils/mp.py

@@ -1,4 +1,5 @@
-from typing import NamedTuple, Optional, Any
+from __future__ import annotations
+from typing import NamedTuple, Any
 from collections.abc import Callable
 import multiprocessing
 import platform
@@ -20,10 +21,10 @@ class Initializer:
     A singleton class with global state used to initialize a multiprocessing.Process
     """
 
-    _single: Optional["Initializer"] = None
+    _single: Initializer | None = None
 
     @classmethod
-    def get(cls) -> "Initializer":
+    def get(cls) -> Initializer:
         """
         A wrapper around init since this class is a singleton
         """

angr/utils/orderedset.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import collections.abc
 
 

angr/utils/segment_list.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-else-break
+from __future__ import annotations
 import logging
 
 from angr.errors import AngrCFGError, AngrRuntimeError
@@ -27,8 +28,7 @@ class Segment:
         self.sort = sort
 
     def __repr__(self):
-        s = f"[{self.start:#x}-{self.end:#x}, {self.sort}]"
-        return s
+        return f"[{self.start:#x}-{self.end:#x}, {self.sort}]"
 
     @property
     def size(self):
@@ -274,7 +274,7 @@ class SegmentList:
                     # |-- address + size --|
                     # no overlap
                     break
-                elif segment.start < address + size <= segment.start + segment.size:
+                if segment.start < address + size <= segment.start + segment.size:
                     #            |---- segment ----|
                     # |-- address + size --|
                     #
@@ -284,7 +284,7 @@ class SegmentList:
                         # remove the segment
                         self._list.remove(segment)
                     break
-                elif address + size > segment.start + segment.size:
+                if address + size > segment.start + segment.size:
                     #            |---- segment ----|
                     # |--------- address + size ----------|
                     self._list.remove(segment)
@@ -432,10 +432,8 @@ class SegmentList:
             return False
         if self._list[idx].start <= address < self._list[idx].end:
             return True
-        if idx > 0 and address < self._list[idx - 1].end:
-            # TODO: It seems that this branch is never reached. Should it be removed?
-            return True
-        return False
+        # TODO: It seems that this is never True. Should it be removed?
+        return idx > 0 and address < self._list[idx - 1].end
 
     def occupied_by_sort(self, address: int) -> str | None:
         """
@@ -521,7 +519,7 @@ class SegmentList:
 
         # self._debug_check()
 
-    def copy(self) -> "SegmentList":
+    def copy(self) -> SegmentList:
         """
         Make a copy of the SegmentList.