angr 9.2.64__py3-none-manylinux2014_x86_64.whl → 9.2.66__py3-none-manylinux2014_x86_64.whl

angr/calling_conventions.py

@@ -1,6 +1,6 @@
 # pylint:disable=line-too-long,missing-class-docstring,no-self-use
 import logging
-from typing import Optional, List, Dict, Type
+from typing import Optional, List, Dict, Type, Union
 from collections import defaultdict
 
 import claripy
@@ -263,7 +263,7 @@ class SimFunctionArgument:
     def refine(self, size, arch=None, offset=None, is_fp=None):
         raise NotImplementedError
 
-    def get_footprint(self):
+    def get_footprint(self) -> List[Union["SimRegArg", "SimStackArg"]]:
         """
         Return a list of SimRegArg and SimStackArgs that are the base components used for this location
         """

angr/code_location.py

@@ -142,3 +142,27 @@ class CodeLocation:
             self.info = {}
         for k, v in kwargs.items():
             self.info[k] = v
+
+
+class ExternalCodeLocation(CodeLocation):
+    """
+    Stands for a program point that originates from outside an analysis' scope.
+    i.e. a value loaded from rdi in a callee where the caller has not been analyzed.
+    """
+
+    __slots__ = ("call_string",)
+
+    def __init__(self, call_string: Optional[Tuple[int, ...]] = None):
+        super().__init__(0, None)
+        self.call_string = call_string if call_string is not None else ()
+
+    def __repr__(self):
+        return f"[External {[hex(x) if isinstance(x, int) else x for x in self.call_string]}]"
+
+    def __hash__(self):
+        """
+        returns the hash value of self.
+        """
+        if self._hash is None:
+            self._hash = hash((self.call_string,))
+        return self._hash

angr/exploration_techniques/__init__.py

@@ -146,3 +146,31 @@ from .bucketizer import Bucketizer
 from .local_loop_seer import LocalLoopSeer
 from .timeout import Timeout
 from .suggestions import Suggestions
+
+__all__ = (
+    "ExplorationTechnique",
+    "Slicecutor",
+    "DrillerCore",
+    "LoopSeer",
+    "Tracer",
+    "Explorer",
+    "Threading",
+    "DFS",
+    "LengthLimiter",
+    "Veritesting",
+    "Oppologist",
+    "Director",
+    "ExecuteAddressGoal",
+    "CallFunctionGoal",
+    "Spiller",
+    "ManualMergepoint",
+    "TechniqueBuilder",
+    "StochasticSearch",
+    "UniqueSearch",
+    "Symbion",
+    "MemoryWatcher",
+    "Bucketizer",
+    "LocalLoopSeer",
+    "Timeout",
+    "Suggestions",
+)

angr/knowledge_plugins/cfg/cfg_model.py

@@ -660,7 +660,7 @@ class CFGModel(Serializable):
 
             # let's see what sort of data it is
             if memory_data.sort in (MemoryDataSort.Unknown, MemoryDataSort.Unspecified) or (
-                memory_data.sort == MemoryDataSort.Integer and memory_data.size == self.project.arch.bytes
+                memory_data.sort == MemoryDataSort.Integer and memory_data.size in (0, self.project.arch.bytes)
             ):
                 data_type, data_size = self._guess_data_type(
                     data_addr,

angr/knowledge_plugins/key_definitions/__init__.py

@@ -1,5 +1,16 @@
 from .rd_model import ReachingDefinitionsModel
 from .key_definition_manager import KeyDefinitionManager
-from .live_definitions import LiveDefinitions
+from .live_definitions import LiveDefinitions, DerefSize
 from .uses import Uses
+from .definition import Definition
 from . import atoms
+
+__all__ = (
+    "ReachingDefinitionsModel",
+    "KeyDefinitionManager",
+    "LiveDefinitions",
+    "DerefSize",
+    "Uses",
+    "atoms",
+    "Definition",
+)

angr/knowledge_plugins/key_definitions/atoms.py

@@ -301,3 +301,12 @@ class MemoryLocation(Atom):
 
     def _identity(self):
         return self.addr, self.size, self.endness
+
+
+atom_kind_mapping = {
+    AtomKind.REGISTER: Register,
+    AtomKind.MEMORY: MemoryLocation,
+    AtomKind.TMP: Tmp,
+    AtomKind.GUARD: GuardUse,
+    AtomKind.CONSTANT: ConstantSrc,
+}

angr/knowledge_plugins/key_definitions/definition.py

@@ -1,4 +1,4 @@
-from typing import Set, Optional, Literal, TypeVar, Union, Generic
+from typing import Set, Optional, Literal, Type, TypeVar, Union, Generic
 from dataclasses import dataclass
 import logging
 
@@ -10,8 +10,8 @@ from angr.sim_variable import SimRegisterVariable
 from angr.misc.ux import once
 
 from ...engines.light import SpOffset
-from ...code_location import CodeLocation
-from .atoms import Atom, MemoryLocation, Register, Tmp, GuardUse, ConstantSrc, AtomKind
+from ...code_location import CodeLocation, ExternalCodeLocation
+from .atoms import Atom, MemoryLocation, Register, Tmp, AtomKind, atom_kind_mapping
 from .tag import Tag
 from ...sim_variable import SimVariable
 
@@ -25,7 +25,7 @@ class DefinitionMatchPredicate:
     internal class; don't worry about this.
     """
 
-    kind: Optional[AtomKind] = None
+    kind: Union[AtomKind, Type[Atom], None] = None
     bbl_addr: Optional[int] = None
     ins_addr: Optional[int] = None
     variable: Optional[SimVariable] = None
@@ -36,6 +36,7 @@ class DefinitionMatchPredicate:
     global_addr: Optional[int] = None
     tmp_idx: Optional[int] = None
     const_val: Optional[int] = None
+    extern: Optional[bool] = None
 
     @staticmethod
     def construct(predicate: Optional["DefinitionMatchPredicate"] = None, **kwargs) -> "DefinitionMatchPredicate":
@@ -96,10 +97,16 @@ class DefinitionMatchPredicate:
             return False
         if self.ins_addr is not None and defn.codeloc.ins_addr != self.ins_addr:
             return False
+        if self.extern is not None and isinstance(defn.codeloc, ExternalCodeLocation) != self.extern:
+            return False
 
-        if isinstance(defn.atom, Register):
-            if self.kind not in (None, AtomKind.REGISTER):
+        if self.kind is not None:
+            if not isinstance(self.kind, type):
+                self.kind = atom_kind_mapping[self.kind]
+            if not isinstance(defn.atom, self.kind):
                 return False
+
+        if isinstance(defn.atom, Register):
             if self.reg_name is not None:
                 if isinstance(self.reg_name, int):
                     if not defn.atom.reg_offset <= self.reg_name < defn.atom.reg_offset + defn.atom.size:
@@ -116,8 +123,6 @@ class DefinitionMatchPredicate:
                 else:
                     raise TypeError(self.reg_name)
         elif isinstance(defn.atom, MemoryLocation):
-            if self.kind not in (None, AtomKind.MEMORY):
-                return False
             if self.stack_offset is not None:
                 if (
                     not isinstance(defn.atom.addr, SpOffset)
@@ -126,18 +131,8 @@ class DefinitionMatchPredicate:
                 ):
                     return False
         elif isinstance(defn.atom, Tmp):
-            if self.kind not in (None, AtomKind.TMP):
-                return False
             if self.tmp_idx is not None and self.tmp_idx != defn.atom.tmp_idx:
                 return False
-        elif isinstance(defn.atom, GuardUse):
-            if self.kind not in (None, AtomKind.GUARD):
-                return False
-        elif isinstance(defn.atom, ConstantSrc):
-            if self.kind not in (None, AtomKind.CONSTANT):
-                return False
-        else:
-            raise TypeError(type(defn))
 
         return True