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

angr/analyses/identifier/identify.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 from collections import defaultdict
 from itertools import chain
@@ -103,9 +104,7 @@ class Identifier(Analysis):
                 l.debug("Simulation error: %s", e)
 
     def _too_large(self):
-        if len(self._cfg.functions) > 400:
-            return True
-        return False
+        return len(self._cfg.functions) > 400
 
     def run(self, only_find=None):
         if only_find is not None:
@@ -192,9 +191,8 @@ class Identifier(Analysis):
             for s in succ:
                 if s in self._cfg.functions:
                     f = self._cfg.functions[s]
-                    if f in self.matches:
-                        if self.matches[f][0] == name:
-                            return True
+                    if f in self.matches and self.matches[f][0] == name:
+                        return True
             to_process.extend(succ)
         return False
 
@@ -320,23 +318,22 @@ class Identifier(Analysis):
             for ss in simgr.active:
                 # todo could write symbolic data to pointers passed to functions
                 if ss.history.jumpkind == "Ijk_Call":
-                    ss.regs.eax = claripy.BVS("unconstrained_ret_%#x" % ss.addr, ss.arch.bits)
+                    ss.regs.eax = claripy.BVS(f"unconstrained_ret_{ss.addr:#x}", ss.arch.bits)
                     ss.regs.ip = ss.stack_pop()
                     ss.history.jumpkind = "Ijk_Ret"
                 if ss.addr == addr_trace[0]:
                     simgr.stashes["active"] = [ss]
                     stepped = True
                     break
-            if not stepped:
-                if len(simgr.unconstrained) > 0:
-                    s = simgr.unconstrained[0]
-                    if s.history.jumpkind == "Ijk_Call":
-                        s.regs.eax = claripy.BVS("unconstrained_ret", s.arch.bits)
-                        s.regs.ip = s.stack_pop()
-                        s.history.jumpkind = "Ijk_Ret"
-                    s.regs.ip = addr_trace[0]
-                    simgr.stashes["active"] = [s]
-                    stepped = True
+            if not stepped and len(simgr.unconstrained) > 0:
+                s = simgr.unconstrained[0]
+                if s.history.jumpkind == "Ijk_Call":
+                    s.regs.eax = claripy.BVS("unconstrained_ret", s.arch.bits)
+                    s.regs.ip = s.stack_pop()
+                    s.history.jumpkind = "Ijk_Ret"
+                s.regs.ip = addr_trace[0]
+                simgr.stashes["active"] = [s]
+                stepped = True
             if not stepped:
                 raise IdentifierException("could not get call args")
             addr_trace = addr_trace[1:]
@@ -368,11 +365,11 @@ class Identifier(Analysis):
         addr_trace = []
         while len(list(calling_func.transition_graph.predecessors(start))) == 1:
             # stop at a call, could continue farther if no stack addr passed etc
-            prev_block = list(calling_func.transition_graph.predecessors(start))[0]
-            addr_trace = [start.addr] + addr_trace
+            prev_block = next(iter(calling_func.transition_graph.predecessors(start)))
+            addr_trace = [start.addr, *addr_trace]
             start = prev_block
 
-        addr_trace = [start.addr] + addr_trace
+        addr_trace = [start.addr, *addr_trace]
         succ_state = None
         while len(addr_trace):
             try:
@@ -422,8 +419,7 @@ class Identifier(Analysis):
         while reg_offset >= 0 and reg_offset >= original_offset - (arch.bytes):
             if reg_offset in arch.register_names:
                 return arch.register_names[reg_offset]
-            else:
-                reg_offset -= 1
+            reg_offset -= 1
         return None
 
     @staticmethod
@@ -475,7 +471,7 @@ class Identifier(Analysis):
         initial_state = self.base_symbolic_state.copy()
 
         reg_dict = {}
-        for r in self._reg_list + [self._bp_reg]:
+        for r in [*self._reg_list, self._bp_reg]:
             reg_dict[hash(initial_state.registers.load(r))] = r
 
         initial_state.regs.ip = func.startpoint.addr
@@ -512,7 +508,7 @@ class Identifier(Analysis):
         # find the end of the preamble
         num_preamble_inst = None
         succ = None
-        for i in range(0, self.project.factory.block(func.startpoint.addr).instructions):
+        for i in range(self.project.factory.block(func.startpoint.addr).instructions):
             if i == 0:
                 succ = initial_state
             if i != 0:
@@ -538,7 +534,7 @@ class Identifier(Analysis):
         initial_sp = initial_state.solver.eval(initial_state.regs.sp)
         frame_size = initial_sp - min_sp - self.project.arch.bytes
         if num_preamble_inst is None or succ is None:
-            raise IdentifierException("preamble checks failed for %#x" % func.startpoint.addr)
+            raise IdentifierException(f"preamble checks failed for {func.startpoint.addr:#x}")
 
         bp_based = bool(len(succ.solver.eval_upto((initial_state.regs.sp - succ.regs.bp), 2)) == 1)
 
@@ -555,10 +551,9 @@ class Identifier(Analysis):
         for a in succ.history.recent_actions:
             if a.type == "mem" and a.action == "write":
                 addr = succ.solver.eval(a.addr.ast)
-                if min_sp <= addr <= initial_sp:
-                    if hash(a.data.ast) in reg_dict:
-                        pushed_regs.append(reg_dict[hash(a.data.ast)])
-        pushed_regs = pushed_regs[::-1]
+                if min_sp <= addr <= initial_sp and hash(a.data.ast) in reg_dict:
+                    pushed_regs.append(reg_dict[hash(a.data.ast)])
+        pushed_regs.reverse()
         # found the preamble
 
         # find the ends of the function
@@ -626,9 +621,10 @@ class Identifier(Analysis):
             written_regs = set()
             # we can get stack variables via memory actions
             for a in succ.history.recent_actions:
-                if a.type == "mem":
-                    if "sym_sp" in a.addr.ast.variables or (bp_based and "sym_bp" in a.addr.ast.variables):
-                        possible_stack_vars.append((addr, a.addr.ast, a.action))
+                if a.type == "mem" and (
+                    "sym_sp" in a.addr.ast.variables or (bp_based and "sym_bp" in a.addr.ast.variables)
+                ):
+                    possible_stack_vars.append((addr, a.addr.ast, a.action))
                 if a.type == "reg" and a.action == "write":
                     # stack variables can also be if a stack addr is loaded into a register, eg lea
                     reg_name = self.get_reg_name(self.project.arch, a.offset)
@@ -657,10 +653,7 @@ class Identifier(Analysis):
                     sp_off = 2**self.project.arch.bits - sp_off
 
                 # get the offsets
-                if bp_based:
-                    bp_off = sp_off - bp_sp_diff
-                else:
-                    bp_off = sp_off - (initial_sp - min_sp) + self.project.arch.bytes
+                bp_off = sp_off - bp_sp_diff if bp_based else sp_off - (initial_sp - min_sp) + self.project.arch.bytes
 
                 stack_var_accesses[bp_off].add((addr, action))
                 stack_vars.add(bp_off)
@@ -737,16 +730,12 @@ class Identifier(Analysis):
             return True
         if len(diff.variables) > 1 or any("ebp" in v for v in diff.variables):
             return False
-        if len(succ.solver.eval_upto((state.regs.sp - succ.regs.bp), 2)) == 1:
-            return True
-        return False
+        return len(succ.solver.eval_upto(state.regs.sp - succ.regs.bp, 2)) == 1
 
     @staticmethod
     def _is_bt(bl):
         # vex does really weird stuff with bit test instructions
-        if bl.bytes.startswith(b"\x0f\xa3"):
-            return True
-        return False
+        return bool(bl.bytes.startswith(b"\x0f\xa3"))
 
     @staticmethod
     def _is_jump_or_call(bl):
@@ -754,19 +743,12 @@ class Identifier(Analysis):
             return True
         if len(bl.vex.constant_jump_targets) != 1:
             return True
-        if next(iter(bl.vex.constant_jump_targets)) != bl.addr + bl.size:
-            return True
-
-        return False
+        return next(iter(bl.vex.constant_jump_targets)) != bl.addr + bl.size
 
     def _no_sp_or_bp(self, bl):
         for s in bl.vex.statements:
             for e in chain([s], s.expressions):
-                if e.tag == "Iex_Get":
-                    reg = self.get_reg_name(self.project.arch, e.offset)
-                    if reg == "ebp" or reg == "esp":
-                        return False
-                elif e.tag == "Ist_Put":
+                if e.tag == "Iex_Get" or e.tag == "Ist_Put":
                     reg = self.get_reg_name(self.project.arch, e.offset)
                     if reg == "ebp" or reg == "esp":
                         return False
@@ -787,9 +769,8 @@ class Identifier(Analysis):
     @staticmethod
     def _non_normal_args(stack_args):
         for i, arg in enumerate(stack_args):
-            if arg != i * 4:
-                return True
-            return False
+            return arg != i * 4
+        return None
 
     @staticmethod
     def make_initial_state(project, stack_length):

angr/analyses/identifier/runner.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import random
 import logging
 import os
@@ -190,7 +191,7 @@ class Runner:
                 curr_buf_loc += max(len(i), 0x1000)
             else:
                 if not isinstance(i, int):
-                    raise Exception("Expected int/bytes got %s" % type(i))
+                    raise Exception(f"Expected int/bytes got {type(i)}")
                 mapped_input.append(i)
 
         cc = self.project.factory.cc()
@@ -217,7 +218,7 @@ class Runner:
                     curr_buf_loc += max(len(i), 0x1000)
                 else:
                     if not isinstance(i, int):
-                        raise Exception("Expected int/str got %s" % type(i))
+                        raise Exception(f"Expected int/str got {type(i)}")
                     mapped_input.append(i)
         else:
             for i, off in zip(test_data.input_args, custom_offs):
@@ -227,7 +228,7 @@ class Runner:
                     curr_buf_loc += max(len(i), 0x1000)
                 else:
                     if not isinstance(i, int):
-                        raise Exception("Expected int/str got %s" % type(i))
+                        raise Exception(f"Expected int/str got {type(i)}")
                     mapped_input.append(i)
 
         cc = self.project.factory.cc()
@@ -323,7 +324,7 @@ class Runner:
                     curr_buf_loc += max(len(i), 0x1000)
                 else:
                     if not isinstance(i, int):
-                        raise Exception("Expected int/bytes got %s" % type(i))
+                        raise Exception(f"Expected int/bytes got {type(i)}")
                     mapped_input.append(i)
 
         else:
@@ -334,7 +335,7 @@ class Runner:
                     curr_buf_loc += max(len(i), 0x1000)
                 else:
                     if not isinstance(i, int):
-                        raise Exception("Expected int/bytes got %s" % type(i))
+                        raise Exception(f"Expected int/bytes got {type(i)}")
                     mapped_input.append(i)
 
         cc = self.project.factory.cc()

angr/analyses/init_finder.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections import defaultdict
 
 from cle.loader import MetaELF
@@ -35,9 +36,7 @@ class SimEngineInitFinderVEX(
     def is_concrete(expr) -> bool:
         if isinstance(expr, claripy.ast.Base) and expr.op == "BVV":
             return True
-        if isinstance(expr, int):
-            return True
-        return False
+        return bool(isinstance(expr, int))
 
     def _is_addr_uninitialized(self, addr):
         # is it writing to a global, uninitialized region?
@@ -68,9 +67,8 @@ class SimEngineInitFinderVEX(
         if isinstance(addr, claripy.ast.Base):
             addr = addr.args[0]
 
-        if isinstance(addr, int):
-            if addr > 0x400:
-                return self.project.loader.find_object_containing(addr) is not None
+        if isinstance(addr, int) and addr > 0x400:
+            return self.project.loader.find_object_containing(addr) is not None
         return False
 
     #
@@ -95,16 +93,19 @@ class SimEngineInitFinderVEX(
             addr_tmp = VEXTmp(stmt.addr.tmp)
             if addr_tmp in self.replacements[blockloc]:
                 addr_v = self.replacements[blockloc][addr_tmp]
-                if self.is_concrete(addr_v) and self._is_addr_uninitialized(addr_v):
+                if (
+                    self.is_concrete(addr_v)
+                    and self._is_addr_uninitialized(addr_v)
+                    and isinstance(stmt.data, pyvex.IRExpr.RdTmp)
+                ):
                     # do we know what it is writing?
-                    if isinstance(stmt.data, pyvex.IRExpr.RdTmp):
-                        data_v = self._expr(stmt.data)
-                        if self.is_concrete(data_v):
-                            if isinstance(data_v, int):
-                                data_size = self.tyenv.sizeof(stmt.data.tmp)
-                                data_v = claripy.BVV(data_v, data_size)
-                            if not self.pointers_only or self._is_pointer(data_v):
-                                self.overlay.store(addr_v, data_v, endness=self.project.arch.memory_endness)
+                    data_v = self._expr(stmt.data)
+                    if self.is_concrete(data_v):
+                        if isinstance(data_v, int):
+                            data_size = self.tyenv.sizeof(stmt.data.tmp)
+                            data_v = claripy.BVV(data_v, data_size)
+                        if not self.pointers_only or self._is_pointer(data_v):
+                            self.overlay.store(addr_v, data_v, endness=self.project.arch.memory_endness)
 
     def _handle_StoreG(self, stmt):
         blockloc = self._codeloc(block_only=True)
@@ -250,8 +251,7 @@ class InitializationFinder(ForwardAnalysis, Analysis):  # pylint:disable=abstrac
 
         if self._node_iterations[block_key] < self._max_iterations:
             return True, None
-        else:
-            return False, None
+        return False, None
 
     def _intra_analysis(self):
         pass

angr/analyses/loop_analysis.py

@@ -1,4 +1,5 @@
 # pylint:disable=missing-class-docstring,no-self-use
+from __future__ import annotations
 import logging
 
 from angr.analyses import ForwardAnalysis, visitors
@@ -52,7 +53,7 @@ class Condition:
             "!=": cls.NotEqual,
         }
 
-        return mapping.get(opstr, None)
+        return mapping.get(opstr)
 
 
 class SootBlockProcessor:
@@ -64,13 +65,13 @@ class SootBlockProcessor:
 
     def process(self):
         if not isinstance(self.block, SootBlockNode):
-            raise AngrLoopAnalysisError("Got an unexpected type of block %s." % type(self.block))
+            raise AngrLoopAnalysisError(f"Got an unexpected type of block {type(self.block)}.")
 
         if not self.block.stmts:
             return None
 
         for stmt in self.block.stmts:
-            func_name = "_handle_%s" % (stmt.__class__.__name__)
+            func_name = f"_handle_{stmt.__class__.__name__}"
 
             if hasattr(self, func_name):
                 getattr(self, func_name)(stmt)
@@ -87,13 +88,10 @@ class SootBlockProcessor:
 
         # TODO: This is slow. Fix the performance issue
 
-        for node in self.loop.body_nodes:
-            if node.addr.stmt_idx <= stmt_idx < node.addr.stmt_idx + node.size:
-                return True
-        return False
+        return any(node.addr.stmt_idx <= stmt_idx < node.addr.stmt_idx + node.size for node in self.loop.body_nodes)
 
     def _expr(self, expr):
-        func_name = "_handle_%s" % (expr.__class__.__name__)
+        func_name = f"_handle_{expr.__class__.__name__}"
 
         if hasattr(self, func_name):
             return getattr(self, func_name)(expr)
@@ -181,8 +179,7 @@ class SootBlockProcessor:
             var_type = mapping[full_method]
 
             if isinstance(base_var, (SootValue, AnnotatedVariable)):
-                annotated_var = AnnotatedVariable(base_var, var_type)
-                return annotated_var
+                return AnnotatedVariable(base_var, var_type)
 
         except KeyError:
             pass
@@ -200,7 +197,7 @@ class LoopAnalysisState:
         self.loop_exit_stmts = set()
 
     def __repr__(self):
-        return "<LoopAnalysisState %s>" % self.block.addr
+        return f"<LoopAnalysisState {self.block.addr}>"
 
     def copy(self):
         state = LoopAnalysisState(block=self.block)
@@ -257,8 +254,7 @@ class LoopAnalysis(ForwardAnalysis, Analysis):
         pass
 
     def _initial_abstract_state(self, node):
-        state = LoopAnalysisState(node)
-        return state
+        return LoopAnalysisState(node)
 
     def _merge_states(self, node, *states):
         merged = states[0]
@@ -344,7 +340,7 @@ class LoopAnalysis(ForwardAnalysis, Analysis):
                 and local.variable == the_iterator
             )
 
-        if not any([check_1(local) for local in self.locals.values()]):
+        if not any(check_1(local) for local in self.locals.values()):
             return None
 
         return True

angr/analyses/loopfinder.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
 import logging
 
 import networkx
 from . import Analysis
+import contextlib
 
 l = logging.getLogger(name=__name__)
 
@@ -16,7 +18,7 @@ class Loop:
         self.graph = graph
         self.subloops = subloops
 
-        self.has_calls = any(map(lambda loop: loop.has_calls, subloops))
+        self.has_calls = any(loop.has_calls for loop in subloops)
 
         if not self.has_calls:
             for _, _, data in self.graph.edges(data=True):
@@ -26,8 +28,7 @@ class Loop:
                     break
 
     def __repr__(self):
-        s = "<Loop @ %s, %d blocks>" % (self.entry.addr, len(self.body_nodes))
-        return s
+        return "<Loop @ %s, %d blocks>" % (self.entry.addr, len(self.body_nodes))
 
 
 class LoopFinder(Analysis):
@@ -113,10 +114,8 @@ class LoopFinder(Analysis):
                     except networkx.NetworkXError:
                         if entry_edge in removed_entries:
                             subg.add_edge(removed_entries[entry_edge], subloop)
-                            try:
+                            with contextlib.suppress(networkx.NetworkXError):
                                 subg.remove_edge(removed_entries[entry_edge], entry_edge[1])
-                            except networkx.NetworkXError:
-                                pass
                         else:
                             raise
                     else:
@@ -128,10 +127,8 @@ class LoopFinder(Analysis):
                     except networkx.NetworkXError:
                         if exit_edge in removed_entries:
                             subg.add_edge(subloop, removed_entries[exit_edge])
-                            try:
+                            with contextlib.suppress(networkx.NetworkXError):
                                 subg.remove_edge(exit_edge[0], removed_entries[exit_edge])
-                            except networkx.NetworkXError:
-                                pass
                         else:
                             raise
                     else:
@@ -143,7 +140,7 @@ class LoopFinder(Analysis):
                 )
                 subg = next(filter(lambda g: entry_node in g.nodes(), _subgraphs))
         me = Loop(entry_node, entry_edges, break_edges, continue_edges, loop_body_nodes, subg, tops[:])
-        return me, [me] + alls
+        return me, [me, *alls]
 
     def _parse_loops_from_graph(self, graph: networkx.DiGraph):
         """
@@ -159,9 +156,8 @@ class LoopFinder(Analysis):
         for subg in (
             networkx.induced_subgraph(graph, nodes).copy() for nodes in networkx.strongly_connected_components(graph)
         ):
-            if len(subg.nodes()) == 1:
-                if len(list(subg.successors(list(subg.nodes())[0]))) == 0:
-                    continue
+            if len(subg.nodes()) == 1 and len(list(subg.successors(next(iter(subg.nodes()))))) == 0:
+                continue
             thisloop, allloops = self._parse_loop_graph(subg, graph)
             if thisloop is not None:
                 outall += allloops

angr/analyses/propagator/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .propagator import PropagatorAnalysis