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

angr/analyses/xrefs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections import defaultdict
 
 import claripy
@@ -108,11 +109,8 @@ class SimEngineXRefsVEX(
                 addr = self.replacements[blockloc][addr_tmp]
                 addr_v = self.extract_value_if_concrete(addr)
                 if addr_v is not None:
-                    if stmt.storedata is None:
-                        # load-link
-                        xref_type = XRefType.Read
-                    else:
-                        xref_type = XRefType.Write
+                    # load-link in true case
+                    xref_type = XRefType.Read if stmt.storedata is None else XRefType.Write
                     self.add_xref(xref_type, self._codeloc(), addr_v)
 
     def _handle_data_offset_refs(self, data_tmp):
@@ -127,12 +125,11 @@ class SimEngineXRefsVEX(
             data_v = self.extract_value_if_concrete(data)
             if data_v is None:
                 return
-            if self.project.loader.find_object_containing(data_v) is not None:
-                # HACK: Avoid spamming Xrefs if the binary is loaded at 0
-                # e.g., firmware!
-                # (magic value chosen due to length of CM EVT)
-                if data_v > 0x200:
-                    self.add_xref(XRefType.Offset, self._codeloc(), data_v)
+            # HACK: Avoid spamming Xrefs if the binary is loaded at 0
+            # e.g., firmware!
+            # (magic value chosen due to length of CM EVT)
+            if self.project.loader.find_object_containing(data_v) is not None and data_v > 0x200:
+                self.add_xref(XRefType.Offset, self._codeloc(), data_v)
 
     #
     # Expression handlers
@@ -250,8 +247,7 @@ class XRefsAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-metho
 
         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/angrdb/__init__.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+
 try:
     import sqlalchemy
-except ImportError:
+except ImportError as err:
     sqlalchemy = None
     raise ImportError(
         "AngrDB relies on SQLAlchemy. Please install SQLAlchemy first by running:\n\tpip install sqlalchemy"
-    )
+    ) from err
 
 from .db import AngrDB

angr/angrdb/db.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 import time
 from contextlib import contextmanager
@@ -39,10 +40,10 @@ class AngrDB:
             Base.metadata.create_all(engine)
             Session = sessionmaker(bind=engine)
             yield Session
-        except DatabaseError:
-            raise AngrCorruptDBError("The target file may not be an angr database or it is corrupted.")
+        except DatabaseError as ex:
+            raise AngrCorruptDBError("The target file may not be an angr database or it is corrupted.") from ex
         except Exception as ex:
-            raise AngrDBError(str(ex))
+            raise AngrDBError(str(ex)) from ex
 
     @staticmethod
     @contextmanager
@@ -145,64 +146,61 @@ class AngrDB:
 
         return version == self.VERSION
 
-    def dump(self, db_path, kbs: list["KnowledgeBase"] | None = None, extra_info: dict[str, Any] | None = None):
-        db_str = "sqlite:///%s" % db_path
+    def dump(self, db_path, kbs: list[KnowledgeBase] | None = None, extra_info: dict[str, Any] | None = None):
+        db_str = f"sqlite:///{db_path}"
 
-        with self.open_db(db_str) as Session:
-            with self.session_scope(Session) as session:
-                # Dump the loader
-                LoaderSerializer.dump(session, self.project.loader)
-                # Dump the knowledge base
+        with self.open_db(db_str) as Session, self.session_scope(Session) as session:
+            # Dump the loader
+            LoaderSerializer.dump(session, self.project.loader)
+            # Dump the knowledge base
 
-                if kbs is None:
-                    kbs = [self.project.kb]
+            if kbs is None:
+                kbs = [self.project.kb]
 
-                for kb in kbs:
-                    KnowledgeBaseSerializer.dump(session, kb)
+            for kb in kbs:
+                KnowledgeBaseSerializer.dump(session, kb)
 
-                # Update the information
-                self.update_dbinfo(session, extra_info=extra_info)
+            # Update the information
+            self.update_dbinfo(session, extra_info=extra_info)
 
     def load(
         self,
         db_path: str,
         kb_names: list[str] | None = None,
-        other_kbs: dict[str, "KnowledgeBase"] | None = None,
+        other_kbs: dict[str, KnowledgeBase] | None = None,
         extra_info: dict[str, Any] | None = None,
     ):
-        db_str = "sqlite:///%s" % db_path
-
-        with self.open_db(db_str) as Session:
-            with self.session_scope(Session) as session:
-                # Compatibility check
-                dbinfo = self.get_dbinfo(session, extra_info=extra_info)
-                if not self.db_compatible(dbinfo.get("version", None)):
-                    raise AngrIncompatibleDBError(
-                        "Version %s is incompatible with the current version of angr." % dbinfo.get("version", None)
-                    )
-
-                # Load the loader
-                loader = LoaderSerializer.load(session)
-                # Create the project
-                proj = Project(loader)
-
-                if kb_names is None:
-                    kb_names = ["global"]
-
-                if len(kb_names) != 1 or kb_names[0] != "global":
-                    if other_kbs is None:
-                        raise ValueError(
-                            'You must provide a dict via "other_kbs" to collect angr KnowledgeBases '
-                            "that are not the global one."
-                        )
-
-                # Load knowledgebases
-                for kb_name in kb_names:
-                    kb = KnowledgeBaseSerializer.load(session, proj, kb_name)
-                    if kb is not None:
-                        if kb_name == "global":
-                            proj.kb = kb
-                        else:
-                            other_kbs[kb_name] = kb
-
-                return proj
+        db_str = f"sqlite:///{db_path}"
+
+        with self.open_db(db_str) as Session, self.session_scope(Session) as session:
+            # Compatibility check
+            dbinfo = self.get_dbinfo(session, extra_info=extra_info)
+            if not self.db_compatible(dbinfo.get("version", None)):
+                raise AngrIncompatibleDBError(
+                    "Version {} is incompatible with the current version of angr.".format(dbinfo.get("version", None))
+                )
+
+            # Load the loader
+            loader = LoaderSerializer.load(session)
+            # Create the project
+            proj = Project(loader)
+
+            if kb_names is None:
+                kb_names = ["global"]
+
+            if (len(kb_names) != 1 or kb_names[0] != "global") and other_kbs is None:
+                raise ValueError(
+                    'You must provide a dict via "other_kbs" to collect angr KnowledgeBases '
+                    "that are not the global one."
+                )
+
+            # Load knowledgebases
+            for kb_name in kb_names:
+                kb = KnowledgeBaseSerializer.load(session, proj, kb_name)
+                if kb is not None:
+                    if kb_name == "global":
+                        proj.kb = kb
+                    else:
+                        other_kbs[kb_name] = kb
+
+            return proj

angr/angrdb/models.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from sqlalchemy import Column, Integer, String, Boolean, BLOB, ForeignKey
 from sqlalchemy.orm import relationship
 from sqlalchemy.ext.declarative import declarative_base

angr/angrdb/serializers/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .loader import LoaderSerializer
 from .kb import KnowledgeBaseSerializer

angr/angrdb/serializers/cfg_model.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-import
+from __future__ import annotations
 from ..models import DbCFGModel
 from ...knowledge_plugins.cfg.cfg_model import CFGModel
 
@@ -37,5 +38,4 @@ class CFGModelSerializer:
         if db_cfg is None:
             return None
 
-        cfg_model = CFGModel.parse(db_cfg.blob, cfg_manager=cfg_manager, loader=loader)
-        return cfg_model
+        return CFGModel.parse(db_cfg.blob, cfg_manager=cfg_manager, loader=loader)

angr/angrdb/serializers/comments.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-import
+from __future__ import annotations
 from ..models import DbComment
 from ...knowledge_plugins.comments import Comments
 

angr/angrdb/serializers/funcs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ...knowledge_plugins import FunctionManager, Function
@@ -14,7 +15,7 @@ class FunctionManagerSerializer:
     """
 
     @staticmethod
-    def dump(session, db_kb: "DbKnowledgeBase", func_manager: FunctionManager):
+    def dump(session, db_kb: DbKnowledgeBase, func_manager: FunctionManager):
         """
 
         :param session:
@@ -35,7 +36,7 @@ class FunctionManagerSerializer:
             session.add(db_func)
 
     @staticmethod
-    def load(session, db_kb: "DbKnowledgeBase", kb: "KnowledgeBase"):
+    def load(session, db_kb: DbKnowledgeBase, kb: KnowledgeBase):
         """
 
         :param session:
@@ -47,7 +48,7 @@ class FunctionManagerSerializer:
         funcs = FunctionManager(kb)
 
         db_funcs = session.query(DbFunction).filter_by(kb=db_kb)
-        all_func_addrs = set(map(lambda x: x[0], session.query(DbFunction.addr).filter_by(kb=db_kb)))
+        all_func_addrs = {x[0] for x in session.query(DbFunction.addr).filter_by(kb=db_kb)}
 
         for db_func in db_funcs:
             func = Function.parse(

angr/angrdb/serializers/kb.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ...knowledge_base import KnowledgeBase
 from ..models import DbKnowledgeBase
 from .cfg_model import CFGModelSerializer
@@ -102,8 +103,8 @@ class KnowledgeBaseSerializer:
 
             # re-initialize CFGModel.insn_addr_to_memory_data
             # fill in insn_addr_to_memory_data
-            for xrefs in xrefs.xrefs_by_ins_addr.values():
-                for xref in xrefs:
+            for xrefs_ in xrefs.xrefs_by_ins_addr.values():
+                for xref in xrefs_:
                     if xref.ins_addr is not None and xref.memory_data is not None:
                         cfg_model.insn_addr_to_memory_data[xref.ins_addr] = xref.memory_data
 

angr/angrdb/serializers/labels.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-import
+from __future__ import annotations
 from ..models import DbLabel
 from ...knowledge_plugins.labels import Labels
 

angr/angrdb/serializers/structured_code.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 import json
 import pickle
@@ -18,7 +19,7 @@ class StructuredCodeManagerSerializer:
     """
 
     @staticmethod
-    def dump(session, db_kb: "DbKnowledgeBase", code_manager: StructuredCodeManager):
+    def dump(session, db_kb: DbKnowledgeBase, code_manager: StructuredCodeManager):
         """
 
         :param session:
@@ -76,7 +77,7 @@ class StructuredCodeManagerSerializer:
         return new_d
 
     @staticmethod
-    def load(session, db_kb: "DbKnowledgeBase", kb: "KnowledgeBase") -> StructuredCodeManager:
+    def load(session, db_kb: DbKnowledgeBase, kb: KnowledgeBase) -> StructuredCodeManager:
         """
 
         :param session:
@@ -102,15 +103,9 @@ class StructuredCodeManagerSerializer:
                 stmt_comments = json.loads(db_code.stmt_comments.decode("utf-8"))
                 stmt_comments = StructuredCodeManagerSerializer.dict_strkey_to_intkey(stmt_comments)
 
-            if not db_code.const_formats:
-                const_formats = None
-            else:
-                const_formats = pickle.loads(db_code.const_formats)
+            const_formats = None if not db_code.const_formats else pickle.loads(db_code.const_formats)
 
-            if not db_code.ite_exprs:
-                ite_exprs = None
-            else:
-                ite_exprs = pickle.loads(db_code.ite_exprs)
+            ite_exprs = None if not db_code.ite_exprs else pickle.loads(db_code.ite_exprs)
 
             configuration = None
             dummy_codegen = DummyStructuredCodeGenerator(

angr/angrdb/serializers/variables.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ...knowledge_plugins import VariableManager
@@ -15,7 +16,7 @@ class VariableManagerSerializer:
     """
 
     @staticmethod
-    def dump(session, db_kb: "DbKnowledgeBase", var_manager: VariableManager):
+    def dump(session, db_kb: DbKnowledgeBase, var_manager: VariableManager):
         # Remove all existing variable collections
         session.query(DbVariableCollection).filter_by(kb=db_kb).delete()
 
@@ -27,15 +28,15 @@ class VariableManagerSerializer:
 
     @staticmethod
     def dump_internal(
-        session, db_kb: "DbKnowledgeBase", internal_manager: VariableManagerInternal, func_addr: int, ident=None
+        session, db_kb: DbKnowledgeBase, internal_manager: VariableManagerInternal, func_addr: int, ident=None
     ):
         blob = internal_manager.serialize()
 
-        db_varcoll = DbVariableCollection(kb=db_kb, ident=None if not ident else ident, func_addr=func_addr, blob=blob)
+        db_varcoll = DbVariableCollection(kb=db_kb, ident=ident if ident else None, func_addr=func_addr, blob=blob)
         session.add(db_varcoll)
 
     @staticmethod
-    def load(session, db_kb: "DbKnowledgeBase", kb: "KnowledgeBase", ident=None):
+    def load(session, db_kb: DbKnowledgeBase, kb: KnowledgeBase, ident=None):
         variable_manager = VariableManager(kb)
 
         db_varcolls = session.query(DbVariableCollection).filter_by(kb=db_kb, ident=ident)
@@ -50,9 +51,8 @@ class VariableManagerSerializer:
 
     @staticmethod
     def load_internal(db_varcoll, variable_manager: VariableManager) -> VariableManagerInternal:
-        internal = VariableManagerInternal.parse(
+        return VariableManagerInternal.parse(
             db_varcoll.blob,
             variable_manager=variable_manager,
             func_addr=db_varcoll.func_addr if db_varcoll.func_addr != -1 else None,
         )
-        return internal

angr/angrdb/serializers/xrefs.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-import
+from __future__ import annotations
 from ..models import DbXRefs
 from ...knowledge_plugins.xrefs import XRefManager
 
@@ -44,5 +45,4 @@ class XRefsSerializer:
         if db_xrefs is None:
             return None
 
-        xrefs = XRefManager.parse(db_xrefs.blob, cfg_model=cfg_model, kb=kb)
-        return xrefs
+        return XRefManager.parse(db_xrefs.blob, cfg_model=cfg_model, kb=kb)

angr/annocfg.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections import defaultdict
 import logging
 
@@ -76,10 +77,9 @@ class AnnotatedCFG:
     def get_addr(self, run):
         if isinstance(run, CFGNode):
             return run.addr
-        elif type(run) is int:
+        if type(run) is int:
             return run
-        else:
-            raise AngrAnnotatedCFGError("Unknown type '%s' of the 'run' argument" % type(run))
+        raise AngrAnnotatedCFGError(f"Unknown type '{type(run)}' of the 'run' argument")
 
     def add_block_to_whitelist(self, block):
         addr = self.get_addr(block)
@@ -123,12 +123,11 @@ class AnnotatedCFG:
     def should_execute_statement(self, addr, stmt_id):
         if self._run_statement_whitelist is None:
             return True
-        elif addr in self._run_statement_whitelist:
+        if addr in self._run_statement_whitelist:
             r = self._run_statement_whitelist[addr]
             if isinstance(r, bool):
                 return r
-            else:
-                return stmt_id in self._run_statement_whitelist[addr]
+            return stmt_id in self._run_statement_whitelist[addr]
         return False
 
     def get_run(self, addr):
@@ -146,11 +145,9 @@ class AnnotatedCFG:
                 # we execute all statements in this basic block. A
                 # little weird...
 
-            else:
-                return self._run_statement_whitelist[addr]
+            return self._run_statement_whitelist[addr]
 
-        else:
-            return []
+        return []
 
     def get_last_statement_index(self, addr):
         """
@@ -167,7 +164,7 @@ class AnnotatedCFG:
             return None
         if addr in self._addr_to_last_stmt_id:
             return self._addr_to_last_stmt_id[addr]
-        elif addr in self._run_statement_whitelist:
+        if addr in self._run_statement_whitelist:
             # is the default exit there? it equals to a negative number (-2 by default) so `max()` won't work.
             if self._run_statement_whitelist[addr] is True or (
                 isinstance(self._run_statement_whitelist[addr], list)
@@ -201,13 +198,13 @@ class AnnotatedCFG:
         for addr, stmts in self._run_statement_whitelist.items():
             if addr is None:
                 continue
-            ret_str += "Address 0x%08x:\n" % addr
+            ret_str += f"Address 0x{addr:08x}:\n"
             l.debug(stmts)
         l.debug("Loops: ")
         for loop in self._loops:
             s = ""
             for addr in loop:
-                s += "0x%08x -> " % addr
+                s += f"0x{addr:08x} -> "
             ret_str += s + "\n"
 
         return ret_str
@@ -226,11 +223,8 @@ class AnnotatedCFG:
         vex_block = project.factory.block(irsb_addr).vex
         statements = vex_block.statements
         whitelist = self.get_whitelisted_statements(irsb_addr)
-        for i in range(0, len(statements)):
-            if whitelist is True or i in whitelist:
-                line = "+"
-            else:
-                line = "-"
+        for i in range(len(statements)):
+            line = "+" if whitelist is True or i in whitelist else "-"
             line += "[% 3d] " % i
             # We cannot get data returned by pp(). WTF?
             print(line, end="")
@@ -253,8 +247,7 @@ class AnnotatedCFG:
         addr = path.addr
         if addr in self._path_merge_points:
             return {self._path_merge_points[addr]}
-        else:
-            return set()
+        return set()
 
     def successor_func(self, path):
         """
@@ -311,10 +304,9 @@ class AnnotatedCFG:
         for source, target_list in self._cfg._edge_map.items():
             for target in target_list:
                 temp_graph.add_edge(source, target)
-        ctr = 0
-        for loop_lst in networkx.simple_cycles(temp_graph):
-            l.debug("A loop is found. %d", ctr)
-            ctr += 1
+
+        for i, loop_lst in enumerate(networkx.simple_cycles(temp_graph)):
+            l.debug("A loop is found. %d", i)
             loop = tuple(x[-1] for x in loop_lst)
-            print(" => ".join(["0x%08x" % x for x in loop]))
+            print(" => ".join([f"0x{x:08x}" for x in loop]))
             self.add_loop(loop)

angr/blade.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import itertools
 
 import networkx
@@ -79,7 +80,7 @@ class Blade:
             raise AngrBladeError('"cfg" must be specified.')
 
         if not self._in_graph(self._dst_run):
-            raise AngrBladeError("The specified SimRun %s doesn't exist in graph." % self._dst_run)
+            raise AngrBladeError(f"The specified SimRun {self._dst_run} doesn't exist in graph.")
 
         self._ignored_regs = set()
         if ignored_regs:
@@ -98,7 +99,7 @@ class Blade:
         elif direction == "forward":
             raise AngrBladeError("Forward slicing is not implemented yet")
         else:
-            raise AngrBladeError("Unknown slicing direction %s" % direction)
+            raise AngrBladeError(f"Unknown slicing direction {direction}")
 
     #
     # Properties
@@ -121,7 +122,7 @@ class Blade:
         block_addrs = {a for a, _ in self.slice.nodes()}
 
         for block_addr in block_addrs:
-            block_str = "       IRSB %#x\n" % block_addr
+            block_str = f"       IRSB {block_addr:#x}\n"
 
             block = self.project.factory.block(
                 block_addr, cross_insn_opt=self._cross_insn_opt, backup_state=self._base_state
@@ -147,11 +148,11 @@ class Blade:
 
             block_str += " + " if default_exit_included else "   "
             if isinstance(block.next, pyvex.IRExpr.Const):
-                block_str += "Next: %#x\n" % block.next.con.value
+                block_str += f"Next: {block.next.con.value:#x}\n"
             elif isinstance(block.next, pyvex.IRExpr.RdTmp):
                 block_str += "Next: t%d\n" % block.next.tmp
             else:
-                block_str += "Next: %s\n" % str(block.next)
+                block_str += f"Next: {block.next!s}\n"
 
             s += block_str
             s += "\n"
@@ -184,14 +185,12 @@ class Blade:
                     v, cross_insn_opt=self._cross_insn_opt, backup_state=self._base_state
                 ).vex
                 if irsb.jumpkind == "Ijk_NoDecode":
-                    raise BadJumpkindNotification()
+                    raise BadJumpkindNotification
                 self._run_cache[v] = irsb
                 return irsb
-            else:
-                raise AngrBladeError("Project must be specified if you give me all addresses for SimRuns")
+            raise AngrBladeError("Project must be specified if you give me all addresses for SimRuns")
 
-        else:
-            raise AngrBladeError("Unsupported SimRun argument type %s" % type(v))
+        raise AngrBladeError(f"Unsupported SimRun argument type {type(v)}")
 
     def _get_cfgnode(self, thing):
         """
@@ -215,17 +214,16 @@ class Blade:
 
         if isinstance(v, CFGNode):
             return v.addr
-        elif type(v) is int:
+        if type(v) is int:
             return v
-        else:
-            raise AngrBladeError("Unsupported SimRun argument type %s" % type(v))
+        raise AngrBladeError(f"Unsupported SimRun argument type {type(v)}")
 
     def _in_graph(self, v):
         return self._get_cfgnode(v) in self._graph
 
     def _inslice_callback(self, stmt_idx, stmt, infodict):  # pylint:disable=unused-argument
         tpl = (infodict["irsb_addr"], stmt_idx)
-        if "prev" in infodict and infodict["prev"]:
+        if infodict.get("prev"):
             prev = infodict["prev"]
             self._slice.add_edge(tpl, prev)
         else:
@@ -279,7 +277,7 @@ class Blade:
                 # A const doesn't rely on anything else!
                 pass
             else:
-                raise AngrBladeError("Unsupported type for irsb.next: %s" % type(next_expr))
+                raise AngrBladeError(f"Unsupported type for irsb.next: {type(next_expr)}")
 
             # Then we gotta start from the very last statement!
             self._dst_stmt_idx = len(stmts) - 1
@@ -326,10 +324,9 @@ class Blade:
                     in_edges = itertools.islice(in_edges, self._max_predecessors)
 
                 for pred, _, data in in_edges:
-                    if "jumpkind" in data:
-                        if self._stop_at_calls and data["jumpkind"] in {"Ijk_Call", "Ijk_Ret"}:
-                            # Skip calls
-                            continue
+                    if "jumpkind" in data and self._stop_at_calls and data["jumpkind"] in {"Ijk_Call", "Ijk_Ret"}:
+                        # Skip calls
+                        continue
                     if self.project.is_hooked(pred.addr):
                         # Skip SimProcedures
                         continue
@@ -417,10 +414,9 @@ class Blade:
                     in_edges = itertools.islice(in_edges, self._max_predecessors)
 
                 for pred, _, data in in_edges:
-                    if "jumpkind" in data:
-                        if self._stop_at_calls and data["jumpkind"] in {"Ijk_Call", "Ijk_Ret"}:
-                            # skip calls as instructed
-                            continue
+                    if "jumpkind" in data and self._stop_at_calls and data["jumpkind"] in {"Ijk_Call", "Ijk_Ret"}:
+                        # skip calls as instructed
+                        continue
                     if self.project.is_hooked(pred.addr):
                         # Stop at SimProcedures
                         continue