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

angr/utils/ssa/__init__.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+from collections import defaultdict
+from typing import Any
+
+import archinfo
+from ailment import Expression, Block
+from ailment.expression import VirtualVariable, Const, Phi, Tmp, Load, Register, StackBaseOffset, DirtyExpression
+from ailment.statement import Statement, Assignment, Call
+from ailment.block_walker import AILBlockWalkerBase
+
+from angr.knowledge_plugins.key_definitions import atoms
+from angr.code_location import CodeLocation
+from .vvar_uses_collector import VVarUsesCollector
+from .tmp_uses_collector import TmpUsesCollector
+
+
+def get_reg_offset_base_and_size(
+    reg_offset: int, arch: archinfo.Arch, size: int | None = None, resilient: bool = True
+) -> tuple[int, int] | None:
+    """
+    Translate a given register offset into the offset of its full register and obtain the size of the full register.
+
+    :param reg_offset:  The offset of the register to translate.
+    :param arch:        The corresponding Arch object.
+    :param size:        Size of the register to translate. Optional.
+    :param resilient:   When set to True, this function will return the provided offset and size for registers that the
+                        arch does not know about.
+    :return:            A tuple of translated offset and the size of the full register.
+    """
+
+    base_reg_and_size = arch.get_base_register(reg_offset, size=size)
+    if resilient and base_reg_and_size is None:
+        return reg_offset, size
+    return base_reg_and_size
+
+
+def get_reg_offset_base(
+    reg_offset: int, arch: archinfo.Arch, size: int | None = None, resilient: bool = True
+) -> int | None:
+    """
+    Translate a given register offset into the offset of its full register.
+
+    :param reg_offset:  The offset of the register to translate.
+    :param arch:        The corresponding Arch object.
+    :param size:        Size of the register to translate. Optional.
+    :param resilient:   When set to True, this function will return the provided offset and size for registers that the
+                        arch does not know about.
+    :return:            The translated offset of the full register.
+    """
+
+    base_reg_and_size = arch.get_base_register(reg_offset, size=size)
+    if base_reg_and_size is None:
+        return reg_offset if resilient else None
+    return base_reg_and_size[0]
+
+
+def get_vvar_deflocs(
+    blocks, phi_vvars: dict[VirtualVariable, set[VirtualVariable]] | None = None
+) -> dict[VirtualVariable, CodeLocation]:
+    vvar_to_loc: dict[VirtualVariable, CodeLocation] = {}
+
+    for block in blocks:
+        for stmt_idx, stmt in enumerate(block.statements):
+            if isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable):
+                vvar_to_loc[stmt.dst] = CodeLocation(block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx)
+                if phi_vvars is not None and isinstance(stmt.src, Phi):
+                    phi_vvars[stmt.dst] = {vvar_ for src, vvar_ in stmt.src.src_and_vvars}
+            elif isinstance(stmt, Call):
+                if isinstance(stmt.ret_expr, VirtualVariable):
+                    vvar_to_loc[stmt.ret_expr] = CodeLocation(
+                        block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx
+                    )
+                if isinstance(stmt.fp_ret_expr, VirtualVariable):
+                    vvar_to_loc[stmt.fp_ret_expr] = CodeLocation(
+                        block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx
+                    )
+
+    return vvar_to_loc
+
+
+def get_vvar_uselocs(blocks) -> dict[int, set[tuple[VirtualVariable, CodeLocation]]]:
+    vvar_to_loc: dict[int, set[tuple[VirtualVariable, CodeLocation]]] = defaultdict(set)
+
+    for block in blocks:
+        collector = VVarUsesCollector()
+        collector.walk(block)
+        for vvar_idx, vvar_and_uselocs in collector.vvar_and_uselocs.items():
+            if vvar_idx not in vvar_to_loc:
+                vvar_to_loc[vvar_idx] = vvar_and_uselocs
+            else:
+                vvar_to_loc[vvar_idx] |= vvar_and_uselocs
+
+    return vvar_to_loc
+
+
+def get_tmp_deflocs(blocks) -> dict[CodeLocation, dict[atoms.Tmp, int]]:
+    tmp_to_loc: dict[CodeLocation, dict[atoms.Tmp, int]] = defaultdict(dict)
+
+    for block in blocks:
+        codeloc = CodeLocation(block.addr, None, block_idx=block.idx)
+        for stmt_idx, stmt in enumerate(block.statements):
+            if isinstance(stmt, Assignment) and isinstance(stmt.dst, Tmp):
+                tmp_to_loc[codeloc][atoms.Tmp(stmt.dst.tmp_idx, stmt.dst.bits)] = stmt_idx
+
+    return tmp_to_loc
+
+
+def get_tmp_uselocs(blocks) -> dict[CodeLocation, dict[atoms.Tmp, set[tuple[Tmp, int]]]]:
+    tmp_to_loc: dict[CodeLocation, dict[atoms.Tmp, set[tuple[Tmp, int]]]] = defaultdict(dict)
+
+    for block in blocks:
+        collector = TmpUsesCollector()
+        collector.walk(block)
+        block_loc = CodeLocation(block.addr, None, block_idx=block.idx)
+        for (tmp_idx, tmp_bits), tmp_and_stmtids in collector.tmp_and_uselocs.items():
+            if tmp_idx not in tmp_to_loc[block_loc]:
+                tmp_to_loc[block_loc][atoms.Tmp(tmp_idx, tmp_bits)] = tmp_and_stmtids
+            else:
+                tmp_to_loc[block_loc][atoms.Tmp(tmp_idx, tmp_bits)] |= tmp_and_stmtids
+
+    return tmp_to_loc
+
+
+def is_const_assignment(stmt: Statement) -> tuple[bool, Const | None]:
+    if isinstance(stmt, Assignment) and isinstance(stmt.src, (Const, StackBaseOffset)):
+        return True, stmt.src
+    return False, None
+
+
+class AILBlacklistExprTypeWalker(AILBlockWalkerBase):
+    """
+    Walks an AIL expression or statement and determines if it does not contain certain types of expressions.
+    """
+
+    def __init__(self, blacklist_expr_types: tuple[type, ...]):
+        super().__init__()
+        self.blacklist_expr_types = blacklist_expr_types
+        self.has_blacklisted_exprs = False
+
+    def _handle_expr(
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
+    ) -> Any:
+        if isinstance(expr, self.blacklist_expr_types):
+            self.has_blacklisted_exprs = True
+            return None
+        return super()._handle_expr(expr_idx, expr, stmt_idx, stmt, block)
+
+
+def is_const_and_vvar_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Load, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_tmp_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Load, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_load_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_load_dirty_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Register, Phi, Call))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_phi_assignment(stmt: Statement) -> tuple[bool, Phi | None]:
+    if isinstance(stmt, Assignment) and isinstance(stmt.src, Phi):
+        return True, stmt.src
+    return False, None
+
+
+__all__ = (
+    "VVarUsesCollector",
+    "get_vvar_deflocs",
+    "get_vvar_uselocs",
+    "is_const_assignment",
+    "is_phi_assignment",
+    "is_const_and_vvar_assignment",
+    "is_const_vvar_load_assignment",
+    "is_const_vvar_load_dirty_assignment",
+    "get_tmp_uselocs",
+    "get_tmp_deflocs",
+)

angr/utils/ssa/tmp_uses_collector.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from collections import defaultdict
+
+from ailment import AILBlockWalkerBase
+from ailment.expression import Tmp
+from ailment.statement import Statement, Assignment
+from ailment.block import Block
+
+
+class TmpUsesCollector(AILBlockWalkerBase):
+    """
+    Collect all uses of temporary variables and their use statement IDs in an AIL block.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.tmp_and_uselocs: dict[tuple[int, int], set[tuple[Tmp, int]]] = defaultdict(set)
+
+    def _handle_Tmp(self, expr_idx: int, expr: Tmp, stmt_idx: int, stmt: Statement, block: Block | None):
+        if isinstance(stmt, Assignment) and expr is stmt.dst:
+            return
+        self.tmp_and_uselocs[(expr.tmp_idx, expr.bits)].add((expr, stmt_idx))

angr/utils/ssa/vvar_uses_collector.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from collections import defaultdict
+
+from ailment import AILBlockWalkerBase
+from ailment.expression import VirtualVariable, Phi
+from ailment.statement import Statement, Assignment
+from ailment.block import Block
+
+from angr.code_location import CodeLocation
+
+
+class VVarUsesCollector(AILBlockWalkerBase):
+    """
+    Collect all uses of virtual variables and their use locations in an AIL block. Skip collecting use locations if
+    block is not specified.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.vvar_and_uselocs: dict[int, set[tuple[VirtualVariable, CodeLocation]]] = defaultdict(set)
+        self.vvars: set[int] = set()
+
+    def _handle_VirtualVariable(
+        self, expr_idx: int, expr: VirtualVariable, stmt_idx: int, stmt: Statement, block: Block | None
+    ):
+        if isinstance(stmt, Assignment):
+            if expr is stmt.dst:
+                return
+            if isinstance(stmt.dst, VirtualVariable) and isinstance(stmt.src, Phi) and expr.varid == stmt.dst.varid:
+                # avoid phi loops
+                return
+        if block is not None:
+            self.vvar_and_uselocs[expr.varid].add(
+                (expr, CodeLocation(block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx))
+            )
+        self.vvars.add(expr.varid)

angr/utils/timing.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-member,global-statement
+from __future__ import annotations
 import os
 import time
 from functools import wraps
@@ -39,7 +40,6 @@ def timethis(func):
                 time_distribution[func].append(millisec)
             depth -= 1
             return r
-        else:
-            return func(*args, **kwargs)
+        return func(*args, **kwargs)
 
     return timed_func

angr/utils/typing.py

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

angr/vaults.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import collections.abc
 import contextlib
 import threading
@@ -53,29 +54,29 @@ class Vault(collections.abc.MutableMapping):
     """
 
     #
-    # These MUST be overriden.
+    # These MUST be overridden.
     #
 
     def _read_context(self, i):
         """
         Should be a context that yields a pickle-read()able file object for the given id i.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _write_context(self, i):
         """
         Should be a context that yields a pickle-write()able file object for the given id i.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def keys(self):
         """
         Should return the IDs stored by the vault.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     #
-    # Persistance managers
+    # Persistence managers
     #
 
     def __init__(self):
@@ -349,9 +350,7 @@ class VaultDirShelf(VaultDict):
     def load(self, oid):
         shelve_path = os.path.join(self._d, oid)
         with self._locked_shelve(shelve_path):
-            o = super().load(oid)
-
-        return o
+            return super().load(oid)
 
     def keys(self):
         s = set()

{angr-9.2.117.dist-info → angr-9.2.118.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.117
+Version: 9.2.118
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 Home-page: https://github.com/angr/angr
 License: BSD-2-Clause
@@ -15,13 +15,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.117
-Requires-Dist: archinfo==9.2.117
+Requires-Dist: ailment==9.2.118
+Requires-Dist: archinfo==9.2.118
 Requires-Dist: cachetools
-Requires-Dist: capstone==5.0.2
+Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.117
-Requires-Dist: cle==9.2.117
+Requires-Dist: claripy==9.2.118
+Requires-Dist: cle==9.2.118
 Requires-Dist: dpkt
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
@@ -31,9 +31,8 @@ Requires-Dist: protobuf>=3.19.0
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.117
+Requires-Dist: pyvex==9.2.118
 Requires-Dist: rich>=13.1.0
-Requires-Dist: rpyc
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy
 Requires-Dist: unicorn==2.0.1.post1