angr 9.2.192__cp311-cp311-macosx_10_12_x86_64.whl

angr/utils/bits.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import claripy
+
+
+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)
+
+
+def ffs(x: int) -> int:
+    return (x & -x).bit_length() - 1
+
+
+def sign_extend(value: int, bits: int) -> int:
+    sign_bit = 1 << (bits - 1)
+    return (value & (sign_bit - 1)) - (value & sign_bit)
+
+
+def zeroextend_on_demand(op0: claripy.ast.BV, op1: claripy.ast.BV) -> claripy.ast.BV:
+    """
+    ZeroExtend op1 if the size of op1 is smaller than the size of op0. Otherwise, return op1.
+    """
+
+    if op0.size() > op1.size():
+        return claripy.ZeroExt(op0.size() - op1.size(), op1)
+    return op1
+
+
+def s2u(s, bits):
+    mask = (1 << bits) - 1
+    if s > 0:
+        return s & mask
+    return ((1 << bits) + s) & mask
+
+
+def u2s(u, bits):
+    if u < (1 << (bits - 1)):
+        return u
+    return (u & ((1 << bits) - 1)) - (1 << bits)

angr/utils/constants.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+DEFAULT_STATEMENT = -2
+SWITCH_MISSING_DEFAULT_NODE_ADDR = 0xFFFF_FFFE
+MAX_POINTSTO_BITS = -1330 * 8
+
+
+def is_alignment_mask(n):
+    return n in {0xFFFFFFFFFFFFFFE0, 0xFFFFFFFFFFFFFFF0, 0xFFFFFFC0, 0xFFFFFFE0, 0xFFFFFFF0, 0xFFFFFFFC, 0xFFFFFFF8}

angr/utils/cowdict.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from collections import ChainMap
+
+
+class ChainMapCOW(ChainMap):
+    """
+    Implements a copy-on-write version of ChainMap that supports auto-collapsing.
+    """
+
+    def __init__(self, *args, collapse_threshold=None):
+        super().__init__(*args)
+        self.dirty = False
+        self.collapse_threshold = collapse_threshold
+
+    def copy(self):
+        self.dirty = True
+        return self
+
+    def clean(self):
+        if self.dirty:
+            # collapse?
+            if self.collapse_threshold is not None and len(self.maps) >= self.collapse_threshold:
+                collapsed = {}
+                for m in reversed(self.maps):
+                    collapsed.update(m)
+                return ChainMapCOW(collapsed, collapse_threshold=self.collapse_threshold)
+            ch = self.new_child()
+            ch.collapse_threshold = self.collapse_threshold
+            return ch
+        return self
+
+
+class DefaultChainMapCOW(ChainMapCOW):
+    """
+    Implements a copy-on-write version of ChainMap with default values that supports auto-collapsing.
+    """
+
+    def __init__(self, *args, default_factory=None, collapse_threshold=None):
+        super().__init__(*args, collapse_threshold=collapse_threshold)
+        self.default_factory = default_factory
+
+    def __getitem__(self, key):
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            self.__setitem__(key, self.default_factory())
+            return super().__getitem__(key)
+
+    def clean(self):
+        if self.dirty:
+            # collapse?
+            if self.collapse_threshold is not None and len(self.maps) >= self.collapse_threshold:
+                collapsed = {}
+                for m in reversed(self.maps):
+                    collapsed.update(m)
+                return DefaultChainMapCOW(
+                    collapsed, default_factory=self.default_factory, collapse_threshold=self.collapse_threshold
+                )
+            r = self.new_child()
+            r.default_factory = self.default_factory
+            r.collapse_threshold = self.collapse_threshold
+            return r
+        return self

angr/utils/cpp.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+def is_cpp_funcname_ctor(name: str) -> bool:
+    """
+    Check if a demangled C++ function name is a constructor.
+
+    :param name:    The demangled C++ function name.
+    :return:        True if the function name is a constructor, False otherwise.
+    """
+
+    # With pydemumble, constructor names look like:
+    #    A::A()
+    if "::" not in name:
+        return False
+    parts = name.split("::")
+    return bool(len(parts) == 2 and parts[0] and parts[0] + "()" == parts[1])

angr/utils/doms.py

@@ -0,0 +1,150 @@
+# pylint:disable=consider-using-dict-items
+from __future__ import annotations
+from typing import Any
+from collections import defaultdict
+
+import networkx
+
+from angr.utils.graph import shallow_reverse
+
+
+class IncrementalDominators:
+    """
+    This class allows for incrementally updating dominators and post-dominators for graphs. The graph must only be
+    modified by replacing nodes, not adding nodes or edges.
+    """
+
+    def __init__(self, graph: networkx.DiGraph, start, post: bool = False):
+        self.graph = graph
+        self.start = start
+        self._post: bool = post  # calculate post-dominators if True
+        self._pre: bool = not post  # calculate dominators
+
+        self._doms: dict[Any, Any] = {}
+        self._dfs: dict[Any, set[Any]] | None = None  # initialized on-demand
+        self._inverted_dom_tree: dict[Any, Any] | None = None  # initialized on demand
+
+        self._doms = self.init_doms()
+
+    def init_doms(self) -> dict[Any, Any]:
+        if self._post:
+            t = shallow_reverse(self.graph)
+            doms = networkx.immediate_dominators(t, self.start)
+        else:
+            doms = networkx.immediate_dominators(self.graph, self.start)
+        doms[self.start] = self.start
+        return doms
+
+    def init_dfs(self) -> dict[Any, set[Any]]:
+        _pred = self.graph.predecessors if self._pre else self.graph.successors
+        df: dict = {}
+        for u in self._doms:
+            _preds = list(_pred(u))  # type:ignore
+            if len(_preds) >= 2:
+                for v in _preds:
+                    if v in self._doms:
+                        while v is not self._doms[u]:
+                            if v not in df:
+                                df[v] = set()
+                            df[v].add(u)
+                            v = self._doms[v]
+        return df
+
+    def _update_inverted_domtree(self):
+        # recalculate the dominators for dominatees of replaced nodes
+        if self._inverted_dom_tree is None:
+            self._inverted_dom_tree = defaultdict(list)
+            for dtee, dtor in self._doms.items():
+                self._inverted_dom_tree[dtor].append(dtee)
+
+    def graph_updated(self, new_node: Any, replaced_nodes: set[Any], replaced_head: Any):
+        self._update_inverted_domtree()
+        assert self._inverted_dom_tree is not None
+
+        # recalculate the dominators for impacted nodes
+        new_dom = self._doms[replaced_head]
+        while new_dom in replaced_nodes and new_dom is not self.start:
+            new_dom = self._doms[new_dom]
+
+        if self.start in replaced_nodes:
+            self.start = new_node
+        if new_dom in replaced_nodes:
+            new_dom = new_node
+
+        new_node_doms = []
+        for rn in replaced_nodes:
+            if rn not in self._inverted_dom_tree:
+                continue
+            for dtee in self._inverted_dom_tree[rn]:
+                self._doms[dtee] = new_node
+                new_node_doms.append(dtee)
+        self._doms[new_node] = new_dom
+
+        if self._dfs is not None:
+            # update dominance frontiers
+            if replaced_head in self._dfs:
+                self._dfs[new_node] = self._dfs[replaced_head]
+            for rn in replaced_nodes:
+                if rn in self._dfs:
+                    del self._dfs[rn]
+                for df in self._dfs.values():
+                    if rn in df:
+                        df.remove(rn)
+                        df.add(new_node)
+
+        # keep inverted dom tree up-to-date
+        self._inverted_dom_tree[new_dom].append(new_node)
+        self._inverted_dom_tree[new_node] = new_node_doms
+        for rn in replaced_nodes:
+            if rn in self._doms:
+                d = self._doms[rn]
+                del self._doms[rn]
+                self._inverted_dom_tree[d].remove(rn)
+            if rn in self._inverted_dom_tree:
+                del self._inverted_dom_tree[rn]
+
+    def idom(self, node: Any) -> Any | None:
+        """
+        Get the immediate dominator of a given node.
+        """
+
+        return self._doms.get(node, None)
+
+    def df(self, node: Any) -> set[Any]:
+        """
+        Generate the dominance frontier of a node.
+        """
+        if self._dfs is None:
+            self._dfs = self.init_dfs()
+        return self._dfs.get(node, set())
+
+    def dominates(self, dominator_node: Any, node: Any) -> bool:
+        """
+        Tests if dominator_node dominates (or post-dominates) node.
+        """
+
+        n = node
+        while n:
+            if n is dominator_node:
+                return True
+            d = self.idom(n)
+            n = d if d is not None and n is not d else None
+        return False
+
+    def _debug_check(self):
+        true_doms = self.init_doms()
+        if len(true_doms) != len(self._doms):
+            raise ValueError("dominators do not match")
+        for k in true_doms:
+            if true_doms[k] != self._doms[k]:
+                print(f"{k!r}: {true_doms[k]!r} {self._doms[k]!r}")
+                raise ValueError("dominators do not match")
+
+        if self._dfs is not None:
+            dfs = self.init_dfs()
+            if len(dfs) != len(self._dfs):
+                raise ValueError("dfs do not match")
+            for k in dfs:
+                if dfs[k] != self._dfs[k]:
+                    print(f"{k!r}: {dfs[k]!r} {self._dfs[k]!r}")
+                    raise ValueError("dfs do not match")

angr/utils/dynamic_dictlist.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+import platform
+from typing import Generic, TypeVar
+
+
+# Ref: https://github.com/angr/angr/pull/3471#issuecomment-1236515950
+LIST2DICT_THRESHOLD = 96 if platform.python_implementation() == "PyPy" else 2048
+
+
+VT = TypeVar("VT")
+
+
+class DynamicDictList(Generic[VT]):
+    """
+    A list-like container class that internally uses dicts to store values when the number of values is less than the
+    threshold `LIST2DICT_THRESHOLD`. Keys must be ints.
+
+    The default thresholds are determined according to experiments described at
+    https://github.com/angr/angr/pull/3471#issuecomment-1236515950.
+    """
+
+    __slots__ = ("dict_content", "list_content", "max_size")
+
+    def __init__(
+        self,
+        max_size: int | 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
+        self.max_size = max_size
+
+        if content:
+            self._initialize_content(content)
+        else:
+            self.dict_content = {}
+
+    def _initialize_content(self, content) -> None:
+        if isinstance(content, DynamicDictList):
+            # make a copy
+            self.list_content = list(content.list_content) if content.list_content is not None else None
+            self.dict_content = dict(content.dict_content) if content.dict_content is not None else None
+            return
+
+        # initializing from a list or a dict
+        if len(content) < LIST2DICT_THRESHOLD:
+            # use a dict
+            if isinstance(content, list):
+                self.dict_content = dict(enumerate(content))
+            else:
+                self.dict_content = dict(content)
+        else:
+            # use a list
+            if isinstance(content, list):
+                self.list_content = list(content)
+            else:
+                self.list_content = [None] * self.max_size
+                for k, v in content.items():
+                    self.list_content[k] = v
+
+    def real_length(self) -> int:
+        if self.dict_content is not None:
+            return len(self.dict_content)
+        return len(self.list_content)
+
+    def __len__(self) -> int:
+        return self.max_size
+
+    def __getitem__(self, key: int) -> VT:
+        if self.dict_content is not None:
+            return self.dict_content.get(key, None)
+        return self.list_content[key]
+
+    def __setitem__(self, key: int, value: VT) -> None:
+        if self.dict_content is not None:
+            self.dict_content[key] = value
+            if len(self.dict_content) >= LIST2DICT_THRESHOLD:
+                # switch
+                self._initialize_content(self.dict_content)
+                self.dict_content = None
+        else:
+            self.list_content[key] = value
+
+    def __iter__(self):
+        if self.dict_content is not None:
+            for i in range(self.max_size):
+                yield self.dict_content.get(i, None)
+        else:
+            yield from self.list_content

angr/utils/endness.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from angr.ailment.expression import Const
+
+
+def ail_const_to_be(expr: Const, endness: str) -> Const:
+    if endness == "Iend_LE" and expr.size > 1:
+        # reverse the expression
+        v = expr.value
+        lst = []
+        while len(lst) < expr.size:
+            lst.append(v & 0xFF)
+            v >>= 8
+        v = 0
+        for elem in lst:
+            v <<= 8
+            v += elem
+        return Const(expr.idx, None, v, expr.bits, **expr.tags)
+    return expr

angr/utils/enums_conv.py

@@ -0,0 +1,97 @@
+# pylint:disable=no-member
+from __future__ import annotations
+import logging
+
+from angr.protos.primitives_pb2 import Edge
+
+l = logging.getLogger(name=__name__)
+
+_CFG_JUMPKINDS = {
+    None: Edge.UnknownJumpkind,
+    "Ijk_8jzf8": Edge._8jzf8,
+    "Ijk_Boring": Edge.Boring,
+    "Ijk_Call": Edge.Call,
+    "Ijk_ClientReq": Edge.ClientReq,
+    "Ijk_EmFail": Edge.EmFail,
+    "Ijk_EmWarn": Edge.EmWarn,
+    "Ijk_Exception": Edge.Exception,
+    "Ijk_FakeRet": Edge.FakeReturn,
+    "Ijk_FlushDCache": Edge.FlushDCache,
+    "Ijk_InvalICache": Edge.InvalICache,
+    "Ijk_MapFail": Edge.MapFail,
+    "Ijk_NoDecode": Edge.NoDecode,
+    "Ijk_NoRedir": Edge.NoRedir,
+    "Ijk_Privileged": Edge.Privileged,
+    "Ijk_Ret": Edge.Return,
+    "Ijk_SigBUS": Edge.SigBUS,
+    "Ijk_SigFPE": Edge.SigFPE,
+    "Ijk_SigFPE_IntDiv": Edge.SigFPE_IntDiv,
+    "Ijk_SigFPE_IntOvf": Edge.SigFPE_IntOvf,
+    "Ijk_SigILL": Edge.SigILL,
+    "Ijk_SigSEGV": Edge.SigSEGV,
+    "Ijk_SigTRAP": Edge.SigTRAP,
+    "Ijk_Syscall": Edge.Syscall,
+    "Ijk_Sys_int": Edge.Sys_int,
+    "Ijk_Sys_int128": Edge.Sys_int128,
+    "Ijk_Sys_int129": Edge.Sys_int129,
+    "Ijk_Sys_int130": Edge.Sys_int130,
+    "Ijk_Sys_int145": Edge.Sys_int145,
+    "Ijk_Sys_int210": Edge.Sys_int210,
+    "Ijk_Sys_int32": Edge.Sys_int32,
+    "Ijk_Sys_syscall": Edge.Sys_syscall,
+    "Ijk_Sys_sysenter": Edge.Sys_sysenter,
+    "Ijk_Yield": Edge.Yield,
+}
+
+
+_PB_TO_CFG_JUMPKINDS = {}
+for k, v in _CFG_JUMPKINDS.items():
+    _PB_TO_CFG_JUMPKINDS[v] = k
+
+
+_FUNCTION_EDGETYPES = {
+    None: Edge.UnknownJumpkind,
+    "transition": Edge.Boring,
+    "call": Edge.Call,
+    "return": Edge.Return,
+    "fake_return": Edge.FakeReturn,
+    "syscall": Edge.Syscall,
+    "exception": Edge.Exception,
+}
+
+
+_PB_TO_FUNCTION_EDGETYPES = {}
+for k, v in _FUNCTION_EDGETYPES.items():
+    _PB_TO_FUNCTION_EDGETYPES[v] = k
+
+
+def cfg_jumpkind_to_pb(jk):
+    try:
+        return _CFG_JUMPKINDS[jk]
+    except KeyError:
+        l.error("Unsupported CFG jumpkind %s in cfg_jumpkind_to_pb. Please report it on GitHub.", jk)
+        return None
+
+
+def func_edge_type_to_pb(jk):
+    try:
+        return _FUNCTION_EDGETYPES[jk]
+    except KeyError:
+        l.error("Unsupported function edge type %s in func_edge_type_to_pb. Please report it on GitHub.", jk)
+        return None
+
+
+def cfg_jumpkind_from_pb(pb):
+    try:
+        return _PB_TO_CFG_JUMPKINDS[pb]
+    except KeyError:
+        l.error("Unsupported protobuf jumpkind %s in cfg_jumpkind_from_pb. Please report it on GitHub.", pb)
+        return None
+
+
+def func_edge_type_from_pb(pb):
+    try:
+        return _PB_TO_FUNCTION_EDGETYPES[pb]
+    except KeyError:
+        l.error("Unsupported protobuf jumpkind %s in func_edge_type_to_pb. Please report it on GitHub.", pb)
+        return None

angr/utils/env.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+import sys
+
+
+def is_pyinstaller() -> bool:
+    """
+    Detect if we are currently running as a PyInstaller-packaged program.
+
+    :return:    True if we are running as a PyInstaller-packaged program. False if we are running in Python directly
+                (e.g., development mode).
+    """
+    return getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")

angr/utils/formatting.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+import os
+import sys
+from collections.abc import Sequence, Callable
+
+
+if sys.platform == "win32":
+    import colorama  # pylint:disable=import-error
+
+
+ansi_color_enabled: bool = False
+
+
+def setup_terminal():
+    """
+    Check if we are running in a TTY. If so, make sure the terminal supports ANSI escape sequences. If not, disable
+    colorized output. Sets global `ansi_color_enabled` to True if colorized output should be enabled by default.
+    """
+    isatty = (
+        hasattr(sys.stdout, "isatty") and sys.stdout.isatty() and hasattr(sys.stderr, "isatty") and sys.stderr.isatty()
+    )
+    if sys.platform == "win32" and isatty:
+        if not isinstance(sys.stdout, colorama.ansitowin32.StreamWrapper):
+            colorama.init()
+
+    global ansi_color_enabled  # pylint:disable=global-statement
+    # https://no-color.org/
+    no_color = os.environ.get("NO_COLOR", "")
+    ansi_color_enabled = isatty and not no_color
+
+
+def ansi_color(s: str, color: str | None) -> str:
+    """
+    Colorize string `s` by wrapping in ANSI escape sequence for given `color`.
+
+    This function does not consider whether escape sequences are functional or not; it is up to the caller to determine
+    if its appropriate. Check global `ansi_color_enabled` value in this module.
+    """
+    if color is None:
+        return s
+
+    codes = {
+        "black": "30m",
+        "bright_black": "90m",
+        "gray": "90m",  # alias 'bright black'
+        "blue": "34m",
+        "bright_blue": "94m",
+        "cyan": "36m",
+        "bright_cyan": "96m",
+        "green": "32m",
+        "bright_green": "92m",
+        "magenta": "35m",
+        "bright_magenta": "95m",
+        "red": "31m",
+        "bright_red": "91m",
+        "white": "37m",
+        "bright_white": "97m",
+        "yellow": "33m",
+        "bright_yellow": "93m",
+    }
+    return "\u001b[" + codes[color] + s + "\u001b[0m"
+
+
+def add_edge_to_buffer(
+    buf: Sequence[str],
+    ref: Sequence[str],
+    start: int,
+    end: int,
+    formatter: Callable[[str], str] | None = None,
+    dashed: bool = False,
+    ascii_only: bool | None = None,
+):
+    """
+    Draw an edge by adding Unicode box and arrow glyphs to beginning of each line in a list of lines.
+
+    :param buf: Output buffer, used to render formatted edges.
+    :param ref: Reference buffer, used to calculate edge depth.
+    :param start: Start line.
+    :param end: End line, where arrow points.
+    :param formatter: Optional callback function used to format the edge before writing it to output buffer.
+    :param dashed: Render edge line dashed instead of solid.
+    :param ascii_only: Render edge using ASCII characters only. If unspecified, guess by stdout encoding.
+    :return:
+    """
+    abs_start = min(start, end)
+    abs_end = max(start, end)
+    max_depth = max(map(len, ref[abs_start : abs_end + 1]))
+    descending = start < end
+
+    if ascii_only is None:
+        # Guess whether we should only use ASCII characters based on stdout encoding
+        ascii_only = getattr(sys.stdout, "encoding", None) != "utf-8"
+
+    if ascii_only:
+        chars = {
+            "start_cap": "-",
+            "start_corner": "+",
+            "end_cap": ">",
+            "end_corner": "+",
+            "horizontal": "+" if dashed else "-",
+            "vertical": "+" if dashed else "|",
+            "spin": "@ ",
+        }
+    else:
+        chars = {
+            "start_cap": "╴",
+            "start_corner": "╭" if descending else "╰",
+            "end_cap": "▸",
+            "end_corner": "╰" if descending else "╭",
+            "horizontal": "╌" if dashed else "─",
+            "vertical": "╎" if dashed else "│",
+            "spin": "⟳ ",
+        }
+
+    def handle_line(i, edge_str):
+        if formatter is not None:
+            edge_str = formatter(edge_str)
+        buf[i] = edge_str + buf[i]
+
+    if start == end:
+        handle_line(start, chars["spin"])
+    else:
+        handle_line(
+            start, (chars["start_corner"] + chars["horizontal"] * (max_depth - len(ref[start])) + chars["start_cap"])
+        )
+        handle_line(end, (chars["end_corner"] + chars["horizontal"] * (max_depth - len(ref[end])) + chars["end_cap"]))
+        for i in range(abs_start + 1, abs_end):
+            handle_line(i, chars["vertical"] + " " * (1 + max_depth - len(ref[i])))