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

angr/analyses/cfg/indirect_jump_resolvers/resolver.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing
 
 from ....errors import SimMemoryError
@@ -8,7 +9,7 @@ if typing.TYPE_CHECKING:
 
 class IndirectJumpResolver:
     def __init__(self, project, timeless=False, base_state=None):
-        self.project: "Project" = project
+        self.project: Project = project
         self.timeless = timeless
         self.base_state = base_state
 
@@ -26,7 +27,7 @@ class IndirectJumpResolver:
         :rtype:  bool
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def resolve(self, cfg, addr, func_addr, block, jumpkind, func_graph_complete: bool = True, **kwargs):
         """
@@ -45,7 +46,7 @@ class IndirectJumpResolver:
         :rtype:                 tuple
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _is_target_valid(self, cfg, target):  # pylint:disable=no-self-use
         """
@@ -68,7 +69,6 @@ class IndirectJumpResolver:
         if cfg._addr_in_exec_memory_regions(target):
             # the jump target is executable
             return True
-        if self.project.is_hooked(target):
-            # the jump target is hooked
-            return True
-        return False
+
+        # if true, the jump target is hooked
+        return bool(self.project.is_hooked(target))

angr/analyses/cfg/indirect_jump_resolvers/x86_elf_pic_plt.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import archinfo
@@ -57,12 +58,9 @@ class X86ElfPicPltResolver(IndirectJumpResolver):
         if block.size != 6:
             return False
 
-        if block.instructions != 1:
-            return False
-
         # TODO: check whether ebx/edx is used
 
-        return True
+        return block.instructions == 1
 
     def resolve(
         self, cfg, addr, func_addr, block, jumpkind, func_graph_complete: bool = True, **kwargs
@@ -77,10 +75,7 @@ class X86ElfPicPltResolver(IndirectJumpResolver):
             # cannot get the base address of GOT
             return False, []
 
-        if cfg._initial_state is not None:
-            state = cfg._initial_state.copy()
-        else:
-            state = self.project.factory.blank_state()
+        state = cfg._initial_state.copy() if cfg._initial_state is not None else self.project.factory.blank_state()
         state.regs.ebx = got_addr
 
         successors = self.project.factory.default_engine.process(state, block, force_addr=addr)

angr/analyses/cfg/indirect_jump_resolvers/x86_pe_iat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 from capstone.x86_const import X86_OP_MEM
@@ -30,9 +31,7 @@ class X86PeIatResolver(IndirectJumpResolver):
 
         opnd = insns[-1].insn.operands[0]
         # Must be of the form: call ds:0xABCD
-        if opnd.type == X86_OP_MEM and opnd.mem.disp and not opnd.mem.base and not opnd.mem.index:
-            return True
-        return False
+        return bool(opnd.type == X86_OP_MEM and opnd.mem.disp and not opnd.mem.base and not opnd.mem.index)
 
     def resolve(
         self, cfg, addr, func_addr, block, jumpkind, func_graph_complete: bool = True, **kwargs

angr/analyses/cfg_slice_to_sink/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .graph import slice_callgraph, slice_cfg_graph, slice_function_graph
 from .cfg_slice_to_sink import CFGSliceToSink

angr/analyses/cfg_slice_to_sink/cfg_slice_to_sink.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 from functools import reduce
 
@@ -69,7 +70,7 @@ class CFGSliceToSink:
 
         :return List[int]: The list of entrypoints addresses.
         """
-        return sorted(list(self._origins - self._destinations))
+        return sorted(self._origins - self._destinations)
 
     def add_transitions(self, transitions):
         """
@@ -93,7 +94,7 @@ class CFGSliceToSink:
 
     def path_between(self, source: int, destination: int, visited: set[Any] | None = None) -> bool:
         """
-        Check the existence of a path in the slice between two given node adresses.
+        Check the existence of a path in the slice between two given node addresses.
 
         :param source: The source address.
         :param destination: The destination address.
@@ -113,5 +114,4 @@ class CFGSliceToSink:
 
         if destination in direct_successors:
             return True
-        else:
-            return any(map(lambda s: self.path_between(s, destination, _visited), direct_successors))
+        return any(self.path_between(s, destination, _visited) for s in direct_successors)

angr/analyses/cfg_slice_to_sink/graph.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 def slice_callgraph(callgraph, cfg_slice_to_sink):
     """
     Slice a callgraph, keeping only the nodes present in the <CFGSliceToSink> representation, and th transitions for
@@ -35,7 +38,7 @@ def slice_cfg_graph(graph, cfg_slice_to_sink):
     """
 
     def _edge_in_slice_transitions(transitions, edge):
-        if edge[0].addr not in transitions.keys():
+        if edge[0].addr not in transitions:
             return False
         return edge[1].addr in cfg_slice_to_sink.transitions[edge[0].addr]
 

angr/analyses/cfg_slice_to_sink/transitions.py

@@ -3,6 +3,8 @@ Some utilitary functions to manage our representation of transitions:
     A dictionary, indexed by int (source addresses), which values are list of ints (target addresses).
 """
 
+from __future__ import annotations
+
 
 def merge_transitions(transitions, existing_transitions):
     """
@@ -15,11 +17,11 @@ def merge_transitions(transitions, existing_transitions):
     """
 
     def _add_to_existing(address, values):
-        if address in existing_transitions.keys():
+        if address in existing_transitions:
             values += existing_transitions[address]
             values = list(set(values))
         existing_transitions.update({address: values})
 
-    list(map(lambda x: _add_to_existing(x[0], x[1]), transitions.items()))
+    [_add_to_existing(x[0], x[1]) for x in transitions.items()]
 
     return existing_transitions

angr/analyses/class_identifier.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ..sim_type import SimCppClass, SimTypeCppFunction
 from ..analyses import AnalysesHub
 from . import Analysis, CFGFast, VtableFinder

angr/analyses/code_tagging.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import pyvex
 
 from ..utils import looks_like_sql
@@ -53,9 +54,7 @@ class CodeTagging(Analysis):
             if block.size == 0:
                 continue
             for stmt in block.vex.statements:
-                if isinstance(stmt, pyvex.IRStmt.Put):
-                    found_xor = found_xor or _has_xor(stmt.data)
-                elif isinstance(stmt, pyvex.IRStmt.WrTmp):
+                if isinstance(stmt, (pyvex.IRStmt.Put, pyvex.IRStmt.WrTmp)):
                     found_xor = found_xor or _has_xor(stmt.data)
             if found_xor:
                 break
@@ -82,9 +81,7 @@ class CodeTagging(Analysis):
             if block.size == 0:
                 continue
             for stmt in block.vex.statements:
-                if isinstance(stmt, pyvex.IRStmt.Put):
-                    found_bitops = found_bitops or _has_bitshifts(stmt.data)
-                elif isinstance(stmt, pyvex.IRStmt.WrTmp):
+                if isinstance(stmt, (pyvex.IRStmt.Put, pyvex.IRStmt.WrTmp)):
                     found_bitops = found_bitops or _has_bitshifts(stmt.data)
 
             if found_bitops:
@@ -113,9 +110,12 @@ class CodeTagging(Analysis):
         xrefs = self.kb.xrefs.get_xrefs_by_ins_addr_region(min_addr, max_addr)
         for xref in xrefs:
             xref: XRef
-            if xref.memory_data is not None and xref.memory_data.sort == "string":
-                if looks_like_sql(xref.memory_data.content.decode("utf-8")):
-                    return {CodeTags.HAS_SQL}
+            if (
+                xref.memory_data is not None
+                and xref.memory_data.sort == "string"
+                and looks_like_sql(xref.memory_data.content.decode("utf-8"))
+            ):
+                return {CodeTags.HAS_SQL}
 
         return False
 

angr/analyses/complete_calling_conventions.py

@@ -1,5 +1,6 @@
 # pylint:disable=import-outside-toplevel
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+from typing import TYPE_CHECKING
 from collections.abc import Callable, Iterable
 import queue
 import threading
@@ -51,7 +52,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
         prioritize_func_addrs: Iterable[int] | None = None,
         skip_other_funcs: bool = False,
         auto_start: bool = True,
-        func_graphs: dict[int, "networkx.DiGraph"] | None = None,
+        func_graphs: dict[int, networkx.DiGraph] | None = None,
     ):
         """
 
@@ -84,7 +85,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
         self._skip_other_funcs = skip_other_funcs
         self._auto_start = auto_start
         self._total_funcs = None
-        self._func_graphs = {} if not func_graphs else func_graphs
+        self._func_graphs = func_graphs if func_graphs else {}
         self.prototype_libnames: set[str] = set()
 
         self._func_addrs = []  # a list that holds addresses of all functions to be analyzed
@@ -139,16 +140,15 @@ class CompleteCallingConventionsAnalysis(Analysis):
                         )
                         continue
 
-                if self._max_function_blocks is not None:
-                    if len(func.block_addrs_set) > self._max_function_blocks:
-                        _l.info(
-                            "Skipping variable recovery for %r since its number of blocks (%d) is greater than the "
-                            "cutoff number (%d).",
-                            func,
-                            len(func.block_addrs_set),
-                            self._max_function_blocks,
-                        )
-                        continue
+                if self._max_function_blocks is not None and len(func.block_addrs_set) > self._max_function_blocks:
+                    _l.info(
+                        "Skipping variable recovery for %r since its number of blocks (%d) is greater than the "
+                        "cutoff number (%d).",
+                        func,
+                        len(func.block_addrs_set),
+                        self._max_function_blocks,
+                    )
+                    continue
 
                 # if it's a normal function, we attempt to perform variable recovery
                 self._func_addrs.append(func_addr)
@@ -161,7 +161,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
         self._prioritize_func_addrs = None  # no longer useful
 
     def _set_function_prototype(
-        self, func: "Function", prototype: Optional["SimTypeFunction"], prototype_libname: str | None
+        self, func: Function, prototype: SimTypeFunction | None, prototype_libname: str | None
     ) -> None:
         if func.prototype is None or func.is_prototype_guessed or self._force:
             func.is_prototype_guessed = True
@@ -171,9 +171,8 @@ class CompleteCallingConventionsAnalysis(Analysis):
     def work(self):
         total_funcs = self._total_funcs
         if self._workers == 0:
-            idx = 0
             self._update_progress(0)
-            for func_addr in self._func_addrs:
+            for idx, func_addr in enumerate(self._func_addrs):
                 cc, proto, proto_libname, _ = self._analyze_core(func_addr)
 
                 func = self.kb.functions.get_by_addr(func_addr)
@@ -186,12 +185,10 @@ class CompleteCallingConventionsAnalysis(Analysis):
                 if self._cc_callback is not None:
                     self._cc_callback(func_addr)
 
-                idx += 1
-
-                percentage = idx / total_funcs * 100.0
-                self._update_progress(percentage, text=f"{idx}/{total_funcs} - {func.demangled_name}")
+                percentage = idx + 1 / total_funcs * 100.0
+                self._update_progress(percentage, text=f"{idx + 1}/{total_funcs} - {func.demangled_name}")
                 if self._low_priority:
-                    self._release_gil(idx, 10, 0.000001)
+                    self._release_gil(idx + 1, 10, 0.000001)
 
         else:
             self._remaining_funcs.value = len(self._func_addrs)
@@ -295,16 +292,15 @@ class CompleteCallingConventionsAnalysis(Analysis):
                 continue
 
             if callee_info is not None:
-                callee_info: dict[int, tuple[Optional["SimCC"], Optional["SimTypeFunction"], str | None]]
+                callee_info: dict[int, tuple[SimCC | None, SimTypeFunction | None, str | None]]
                 for callee, (callee_cc, callee_proto, callee_proto_libname) in callee_info.items():
                     callee_func = self.kb.functions.get_by_addr(callee)
                     callee_func.calling_convention = callee_cc
                     self._set_function_prototype(callee_func, callee_proto, callee_proto_libname)
 
             idx += 1
-            if self._low_priority:
-                if idx % 3 == 0:
-                    time.sleep(0.1)
+            if self._low_priority and idx % 3 == 0:
+                time.sleep(0.1)
 
             try:
                 cc, proto, proto_libname, varman = self._analyze_core(func_addr)
@@ -316,7 +312,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
 
     def _analyze_core(
         self, func_addr: int
-    ) -> tuple[Optional["SimCC"], Optional["SimTypeFunction"], Optional["str"], Optional["VariableManagerInternal"]]:
+    ) -> tuple[SimCC | None, SimTypeFunction | None, str | None, VariableManagerInternal | None]:
         func = self.kb.functions.get_by_addr(func_addr)
         if func.ran_cca:
             return (
@@ -328,10 +324,9 @@ class CompleteCallingConventionsAnalysis(Analysis):
 
         if self._recover_variables and self.function_needs_variable_recovery(func):
             # special case: we don't have a PCode-engine variable recovery analysis for PCode architectures!
-            if ":" in self.project.arch.name:
+            if ":" in self.project.arch.name and self._func_graphs and func.addr in self._func_graphs:
                 # this is a pcode architecture
-                if not self._func_graphs or func.addr not in self._func_graphs:
-                    return None, None, None, None
+                return None, None, None, None
 
             _l.info("Performing variable recovery on %r...", func)
             try:
@@ -359,9 +354,8 @@ class CompleteCallingConventionsAnalysis(Analysis):
                 func.prototype_libname,
                 self.kb.variables.get_function_manager(func_addr),
             )
-        else:
-            _l.info("Cannot determine calling convention for %r.", func)
-            return None, None, None, self.kb.variables.get_function_manager(func_addr)
+        _l.info("Cannot determine calling convention for %r.", func)
+        return None, None, None, self.kb.variables.get_function_manager(func_addr)
 
     def prioritize_functions(self, func_addrs_to_prioritize: Iterable[int]):
         """
@@ -385,7 +379,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
 
     def _get_callees_cc_prototypes(
         self, caller_func_addr: int
-    ) -> dict[int, tuple[Optional["SimCC"], Optional["SimTypeFunction"], str | None]]:
+    ) -> dict[int, tuple[SimCC | None, SimTypeFunction | None, str | None]]:
         d = {}
         for callee in self.kb.functions.callgraph.successors(caller_func_addr):
             if callee != caller_func_addr and callee not in d:
@@ -415,10 +409,8 @@ class CompleteCallingConventionsAnalysis(Analysis):
         :rtype:         bool
         """
 
-        if func.is_simprocedure or func.is_plt:
-            return False
         # TODO: Check SimLibraries
-        return True
+        return not (func.is_simprocedure or func.is_plt)
 
 
 register_analysis(CompleteCallingConventionsAnalysis, "CompleteCallingConventions")

angr/analyses/congruency_check.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -33,12 +34,10 @@ class CongruencyCheck(Analysis):
         s_right = self.project.factory.full_init_state(
             add_options=right_add_options,
             remove_options=right_remove_options,
-            args=[],
         )
         s_left = self.project.factory.full_init_state(
             add_options=left_add_options,
             remove_options=left_remove_options,
-            args=[],
         )
 
         return self.set_states(s_left, s_right)
@@ -177,13 +176,11 @@ class CongruencyCheck(Analysis):
                     self.simgr.stashes[unicorn_stash][0] = new_unicorn
                     self.simgr.stashes[normal_stash][0] = new_normal
                     return False
-                else:
-                    l.warning("Divergence unaccounted for by unicorn.")
-                    return True
-            else:
-                # no idea
-                l.warning("Divergence unaccounted for.")
+                l.warning("Divergence unaccounted for by unicorn.")
                 return True
+            # no idea
+            l.warning("Divergence unaccounted for.")
+            return True
         finally:
             self._throw = ot
 
@@ -262,6 +259,7 @@ class CongruencyCheck(Analysis):
             if len(self.simgr.left) > 1:
                 self.simgr.split(from_stash="left", limit=1, to_stash="stashed_left")
                 self.simgr.split(from_stash="right", limit=1, to_stash="stashed_right")
+        return None
 
     def compare_path_group(self, pg):
         if len(pg.left) != len(pg.right):
@@ -346,9 +344,6 @@ class CongruencyCheck(Analysis):
 
         # make sure the flags are the same
         if sl.arch.name in ("AMD64", "X86", "ARM", "ARMEL", "ARMHF", "AARCH64"):
-            # pylint: disable=unused-variable
-            sr.regs.cc_op, sr.regs.cc_dep1, sr.regs.cc_dep2, sr.regs.cc_ndep  # n_bkp
-            sl.regs.cc_op, sl.regs.cc_dep1, sl.regs.cc_dep2, sl.regs.cc_ndep  # u_bkp
             if sl.arch.name in ("AMD64", "X86"):
                 n_flags = sr.regs.eflags.canonicalize(var_map=n_map, counter=n_counter)[-1]
                 u_flags = sl.regs.eflags.canonicalize(var_map=u_map, counter=u_counter)[-1]

angr/analyses/data_dep/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .data_dependency_analysis import DataDependencyGraphAnalysis
 from .dep_nodes import DepNodeTypes, BaseDepNode, VarDepNode, MemDepNode, ConstantDepNode, TmpDepNode, RegDepNode