angr 9.2.123__py3-none-macosx_11_0_arm64.whl → 9.2.125__py3-none-macosx_11_0_arm64.whl

angr/knowledge_plugins/functions/function.py

@@ -56,6 +56,7 @@ class Function(Serializable):
         "addr",
         "is_simprocedure",
         "_name",
+        "previous_names",
         "is_default_name",
         "from_signature",
         "binary_name",
@@ -224,6 +225,7 @@ class Function(Serializable):
         else:
             self.is_default_name = False
             self._name = name
+        self.previous_names = []
         self.from_signature = None
 
         # Determine the name the binary where this function is.
@@ -274,6 +276,7 @@ class Function(Serializable):
 
     @name.setter
     def name(self, v):
+        self.previous_names.append(self._name)
         self._name = v
         self._function_manager._kb.labels[self.addr] = v
 
@@ -1667,6 +1670,7 @@ class Function(Serializable):
         func._endpoints = self._endpoints.copy()
         func._call_sites = self._call_sites.copy()
         func._project = self._project
+        func.previous_names = list(self.previous_names)
         func.is_plt = self.is_plt
         func.is_simprocedure = self.is_simprocedure
         func.binary_name = self.binary_name

angr/knowledge_plugins/functions/function_manager.py

@@ -313,7 +313,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         if isinstance(k, self.function_address_types):
             f = self.function(addr=k)
         elif type(k) is str:
-            f = self.function(name=k)
+            f = self.function(name=k) or self.function(name=k, check_previous_names=True)
         else:
             raise ValueError(f"FunctionManager.__getitem__ does not support keys of type {type(k)}")
 
@@ -350,9 +350,9 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
     def get_by_addr(self, addr) -> Function:
         return self._function_map.get(addr)
 
-    def get_by_name(self, name: str) -> Generator[Function]:
+    def get_by_name(self, name: str, check_previous_names: bool = False) -> Generator[Function]:
         for f in self._function_map.values():
-            if f.name == name:
+            if f.name == name or (check_previous_names and name in f.previous_names):
                 yield f
 
     def _function_added(self, func: Function):
@@ -411,7 +411,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         except KeyError:
             return None
 
-    def query(self, query: str) -> Function | None:
+    def query(self, query: str, check_previous_names: bool = False) -> Function | None:
         """
         Query for a function using selectors to disambiguate. Supported variations:
 
@@ -430,19 +430,21 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
                 addr = int(matches.group(2), 0)
                 try:
                     func = self._function_map.get(addr)
-                    if func.name == name:
+                    if func.name == name or (check_previous_names and name in func.previous_names):
                         return func
                 except KeyError:
                     pass
 
             obj_name = selector or self._kb._project.loader.main_object.binary_basename
-            for func in self.get_by_name(name):
+            for func in self.get_by_name(name, check_previous_names=check_previous_names):
                 if func.binary_name == obj_name:
                     return func
 
         return None
 
-    def function(self, addr=None, name=None, create=False, syscall=False, plt=None) -> Function | None:
+    def function(
+        self, addr=None, name=None, check_previous_names=False, create=False, syscall=False, plt=None
+    ) -> Function | None:
         """
         Get a function object from the function manager.
 
@@ -457,6 +459,13 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         :return: The Function instance, or None if the function is not found and create is False.
         :rtype: Function or None
         """
+        if name is not None and name.startswith("sub_"):
+            try:
+                addr = int(name.split("_")[-1], 16)
+                name = None
+            except ValueError:
+                pass
+
         if addr is not None:
             try:
                 f = self._function_map.get(addr)
@@ -472,11 +481,11 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
                         f.is_syscall = True
                     return f
         elif name is not None:
-            func = self.query(name)
+            func = self.query(name, check_previous_names=check_previous_names)
             if func is not None:
                 return func
 
-            for func in self.get_by_name(name):
+            for func in self.get_by_name(name, check_previous_names=check_previous_names):
                 if plt is None or func.is_plt == plt:
                     return func
 

angr/knowledge_plugins/functions/function_parser.py

@@ -33,7 +33,7 @@ class FunctionParser:
         obj.is_syscall = function.is_syscall
         obj.is_simprocedure = function.is_simprocedure
         obj.returning = function.returning
-        obj.alignment = function.alignment
+        obj.alignment = function.is_alignment
         obj.binary_name = function.binary_name or ""
         obj.normalized = function.normalized
 

angr/knowledge_plugins/functions/soot_function.py

@@ -34,6 +34,7 @@ class SootFunction(Function):
         # block nodes (basic block nodes) at whose ends the function terminates
         # in theory, if everything works fine, endpoints == ret_sites | jumpout_sites | callout_sites
         self._endpoints = defaultdict(set)
+        self.previous_names = []
 
         self._call_sites = {}
         self.addr = addr

angr/knowledge_plugins/key_definitions/atoms.py

@@ -277,6 +277,10 @@ class VirtualVariable(Atom):
     def was_parameter(self) -> bool:
         return self.category == ailment.Expr.VirtualVariableCategory.PARAMETER
 
+    @property
+    def was_tmp(self) -> bool:
+        return self.category == ailment.Expr.VirtualVariableCategory.TMP
+
     @property
     def reg_offset(self) -> int | None:
         if self.was_reg:
@@ -289,6 +293,10 @@ class VirtualVariable(Atom):
             return self.oident
         return None
 
+    @property
+    def tmp_idx(self) -> int | None:
+        return self.oident if self.was_tmp else None
+
 
 class MemoryLocation(Atom):
     """

angr/misc/ux.py

@@ -20,9 +20,9 @@ def deprecated(replacement=None):
         def inner(*args, **kwargs):
             if func not in already_complained:
                 if replacement is None:
-                    warnings.warn(f"Don't use {func.__name__}", DeprecationWarning, stacklevel=1)
+                    warnings.warn(f"Don't use {func.__name__}", DeprecationWarning, stacklevel=2)
                 else:
-                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning, stacklevel=1)
+                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning, stacklevel=2)
                 already_complained.add(func)
             return func(*args, **kwargs)
 

angr/procedures/definitions/parse_win32json.py

@@ -162,7 +162,8 @@ def do_it(in_dir, out_file):
 
     for file in files:
         logging.info("Found file %s", file)
-        api_namespaces[file.stem] = json.load(codecs.open(file, "r", "utf-8-sig"))
+        with codecs.open(file, "r", "utf-8-sig") as f:
+            api_namespaces[file.stem] = json.load(f)
 
     logging.info("Making a bunch of types...")
     missing_types_last_round = set()

angr/project.py

@@ -236,7 +236,7 @@ class Project:
         self._initialize_analyses_hub()
 
         # Step 5.3: ...etc
-        self.kb = KnowledgeBase(self, name="global")
+        self._knowledge_bases = {"default": KnowledgeBase(self, name="global")}
 
         self.is_java_project = isinstance(self.arch, ArchSoot)
         self.is_java_jni_project = isinstance(self.arch, ArchSoot) and getattr(
@@ -257,6 +257,22 @@ class Project:
         # Step 7: Run OS-specific configuration
         self.simos.configure_project()
 
+    @property
+    def kb(self):
+        return self._knowledge_bases["default"]
+
+    @kb.setter
+    def kb(self, kb):
+        self._knowledge_bases["default"] = kb
+
+    def get_kb(self, name):
+        try:
+            return self._knowledge_bases[name]
+        except KeyError:
+            kb = KnowledgeBase(self, name)
+            self._knowledge_bases[name] = kb
+            return kb
+
     @property
     def analyses(self) -> AnalysesHubWithDefault:
         result = self._analyses

angr/state_plugins/history.py

@@ -63,9 +63,11 @@ class SimStateHistory(SimStatePlugin):
         self.successor_ip = None if clone is None else clone.successor_ip
 
         self.strongref_state = None if clone is None else clone.strongref_state
+        self.arch = None
 
     def init_state(self):
         self.successor_ip = self.state._ip
+        self.arch = self.state.arch
 
     def __getstate__(self):
         # flatten ancestry, otherwise we hit recursion errors trying to get the entire history...
@@ -217,7 +219,7 @@ class SimStateHistory(SimStatePlugin):
                 read_offset = None
             elif isinstance(read_from, str):
                 read_type = "reg"
-                read_offset = self.state.project.arch.registers[read_from][0]
+                read_offset = self.arch.registers[read_from][0]
             else:
                 read_type = "mem"
                 read_offset = read_from
@@ -227,7 +229,7 @@ class SimStateHistory(SimStatePlugin):
                 write_offset = None
             elif isinstance(write_to, str):
                 write_type = "reg"
-                write_offset = self.state.project.arch.registers[write_to][0]
+                write_offset = self.arch.registers[write_to][0]
             else:
                 write_type = "mem"
                 write_offset = write_to
@@ -256,7 +258,7 @@ class SimStateHistory(SimStatePlugin):
             if isinstance(addr, claripy.ast.Base):
                 if addr.symbolic:
                     return False
-                addr = self.state.solver.eval(addr)
+                addr = addr.concrete_value
             return addr == read_offset
 
         def action_writes(action):
@@ -272,7 +274,7 @@ class SimStateHistory(SimStatePlugin):
             if isinstance(addr, claripy.ast.Base):
                 if addr.symbolic:
                     return False
-                addr = self.state.solver.eval(addr)
+                addr = addr.concrete_value
             return addr == write_offset
 
         return [

angr/storage/memory_mixins/actions_mixin.py

@@ -7,7 +7,7 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 
 class ActionsMixinHigh(MemoryMixin):
-    def load(self, addr, size=None, condition=None, fallback=None, disable_actions=False, action=None, **kwargs):
+    def load(self, addr, size=None, *, condition=None, fallback=None, disable_actions=False, action=None, **kwargs):
         if not disable_actions and o.AUTO_REFS in self.state.options and action is None:
             action = self.__make_action("read", addr, size, None, condition, fallback)
 
@@ -28,7 +28,7 @@ class ActionsMixinHigh(MemoryMixin):
 
         return r
 
-    def store(self, addr, data, size=None, disable_actions=False, action=None, condition=None, **kwargs):
+    def store(self, addr, data, size=None, *, disable_actions=False, action=None, condition=None, **kwargs):
         if not disable_actions and o.AUTO_REFS in self.state.options and action is None:
             action = self.__make_action("write", addr, size, data, condition, None)
 
@@ -49,24 +49,24 @@ class ActionsMixinHigh(MemoryMixin):
         action.added_constraints = claripy.true()
         return action
 
-    def _add_constraints(self, c, action=None, **kwargs):
+    def _add_constraints(self, c, *, action=None, **kwargs):
         if action is not None:
             action.added_constraints = claripy.And(action.added_constraints, c)
         return super()._add_constraints(c, action=action, **kwargs)
 
 
 class ActionsMixinLow(MemoryMixin):
-    def load(self, addr, action=None, **kwargs):
+    def load(self, addr, size=None, *, action=None, **kwargs):
         if action is not None:
             if action.actual_addrs is None:
                 action.actual_addrs = []
             action.actual_addrs.append(addr)
-        return super().load(addr, action=action, **kwargs)
+        return super().load(addr, size, action=action, **kwargs)
 
-    def store(self, addr, data, action: SimActionData | None = None, **kwargs):
+    def store(self, addr, data, size=None, *, action: SimActionData | None = None, **kwargs):
         if action is not None:
             if action.actual_addrs is None:
                 action.actual_addrs = []
             action.actual_addrs.append(addr)
             action.actual_value = action._make_object(data)
-        return super().store(addr, data, action=action, **kwargs)
+        return super().store(addr, data, size, action=action, **kwargs)

angr/storage/memory_mixins/address_concretization_mixin.py

@@ -230,7 +230,7 @@ class AddressConcretizationMixin(MemoryMixin):
         """
         Take a list of integers and return a new list of integers where front and back integers interleave.
         """
-        lst = [None] * len(addrs)
+        lst = [0xFACE] * len(addrs)
         front, back = 0, len(addrs) - 1
         i = 0
         while front <= back:
@@ -257,7 +257,7 @@ class AddressConcretizationMixin(MemoryMixin):
             return sub_value
         return claripy.If(addr == concrete_addr, sub_value, read_value)
 
-    def load(self, addr, size=None, condition=None, **kwargs):
+    def load(self, addr, size=None, *, condition=None, **kwargs):
         if type(size) is not int:
             raise TypeError("Size must have been specified as an int before reaching address concretization")
 
@@ -309,7 +309,7 @@ class AddressConcretizationMixin(MemoryMixin):
                 sub_condition = condition & sub_condition
         super().store(concrete_addr, data, size=size, condition=sub_condition, **kwargs)
 
-    def store(self, addr, data, size=None, condition=None, **kwargs):
+    def store(self, addr, data, size=None, *, condition=None, **kwargs):
         # Fast path
         if type(addr) is int:
             self._store_one_addr(addr, data, True, addr, condition, size, **kwargs)
@@ -374,11 +374,11 @@ class AddressConcretizationMixin(MemoryMixin):
             raise SimMemoryAddressError("Cannot unmap a region for a symbolic address")
         return super().unmap_region(addr, length, **kwargs)
 
-    def concrete_load(self, addr, size, *args, **kwargs):
+    def concrete_load(self, addr, size, writing=False, **kwargs):
         if type(addr) is int:
             pass
         elif getattr(addr, "op", None) == "BVV":
             addr = addr.args[0]
         else:
             raise SimMemoryAddressError("Cannot unmap a region for a symbolic address")
-        return super().concrete_load(addr, size, *args, **kwargs)
+        return super().concrete_load(addr, size, writing=writing, **kwargs)

angr/storage/memory_mixins/bvv_conversion_mixin.py

@@ -26,7 +26,7 @@ class DataNormalizationMixin(MemoryMixin):
 
         super().store(addr, data_bv, size=size, **kwargs)
 
-    def load(self, addr, size=None, fallback=None, **kwargs):
+    def load(self, addr, size=None, *, fallback=None, **kwargs):
         fallback_bv = self._convert_to_ast(fallback, size, self.state.arch.byte_width) if fallback is not None else None
         return super().load(addr, size=size, fallback=fallback_bv, **kwargs)
 

angr/storage/memory_mixins/clouseau_mixin.py

@@ -4,7 +4,7 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 
 class InspectMixinHigh(MemoryMixin):
-    def store(self, addr, data, size=None, condition=None, endness=None, inspect=True, **kwargs):
+    def store(self, addr, data, size=None, *, condition=None, endness=None, inspect=True, **kwargs):
         if not inspect or not self.state.supports_inspect:
             super().store(addr, data, size=size, condition=condition, endness=endness, inspect=inspect, **kwargs)
             return
@@ -63,7 +63,7 @@ class InspectMixinHigh(MemoryMixin):
                 mem_write_endness=endness,
             )
 
-    def load(self, addr, size=None, condition=None, endness=None, inspect=True, **kwargs):
+    def load(self, addr, size=None, *, condition=None, endness=None, inspect=True, **kwargs):
         if not inspect or not self.state.supports_inspect:
             return super().load(addr, size=size, condition=condition, endness=endness, inspect=inspect, **kwargs)
 
@@ -122,7 +122,7 @@ class InspectMixinHigh(MemoryMixin):
 
         return r
 
-    def _add_constraints(self, c, add_constraints=True, inspect=True, **kwargs):
+    def _add_constraints(self, c, *, add_constraints=True, inspect=True, **kwargs):
         if inspect and self.state.supports_inspect:
             # tracer uses address_concretization_add_constraints
             add_constraints = self.state._inspect_getattr("address_concretization_add_constraints", add_constraints)

angr/storage/memory_mixins/conditional_store_mixin.py

@@ -5,13 +5,13 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 
 class ConditionalMixin(MemoryMixin):
-    def load(self, addr, condition=None, fallback=None, **kwargs):
-        res = super().load(addr, condition=condition, **kwargs)
+    def load(self, addr, size=None, *, condition=None, fallback=None, **kwargs):
+        res = super().load(addr, size, condition=condition, **kwargs)
         if condition is not None and fallback is not None:
             res = claripy.If(condition, res, fallback)
         return res
 
-    def store(self, addr, data, size=None, condition=None, **kwargs):
+    def store(self, addr, data, size=None, *, condition=None, **kwargs):
         condition = self.state._adjust_condition(condition)
 
         if condition is None or self.state.solver.is_true(condition):

angr/storage/memory_mixins/default_filler_mixin.py

@@ -13,7 +13,7 @@ l = logging.getLogger(__name__)
 
 class DefaultFillerMixin(MemoryMixin):
     def _default_value(
-        self, addr, size, name=None, inspect=True, events=True, key=None, fill_missing: bool = True, **kwargs
+        self, addr, size, *, name=None, inspect=True, events=True, key=None, fill_missing: bool = True, **kwargs
     ):
         if self.state.project and self.state.project.concrete_target:
             mem = self.state.project.concrete_target.read_memory(addr, size)
@@ -115,7 +115,7 @@ class SpecialFillerMixin(MemoryMixin):
         super().__init__(**kwargs)
         self._special_memory_filler = special_memory_filler
 
-    def _default_value(self, addr, size, name=None, **kwargs):
+    def _default_value(self, addr, size, *, name=None, **kwargs):
         if (
             options.SPECIAL_MEMORY_FILL in self.state.options
             and self.state._special_memory_filler is not None
@@ -135,7 +135,7 @@ class ExplicitFillerMixin(MemoryMixin):
         super().__init__(**kwargs)
         self._uninitialized_read_handler = uninitialized_read_handler
 
-    def _default_value(self, addr, size, inspect=True, events=True, **kwargs):
+    def _default_value(self, addr, size, *, inspect=True, events=True, **kwargs):
         if self._uninitialized_read_handler is not None:
             return self._uninitialized_read_handler(addr, size, inspect=inspect, events=events)
         return super()._default_value(addr, size, inspect=inspect, events=events, **kwargs)

angr/storage/memory_mixins/memory_mixin.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Any
+from typing import Any, Generic, TypeVar
+from typing_extensions import Self
 
 import claripy
 
@@ -9,33 +10,44 @@ from angr.errors import SimMemoryError
 from angr.state_plugins.plugin import SimStatePlugin
 
 
-class MemoryMixin(SimStatePlugin):
+InData = TypeVar("InData")
+OutData = TypeVar("OutData")
+Addr = TypeVar("Addr")
+
+
+class MemoryMixin(Generic[InData, OutData, Addr], SimStatePlugin):
     """
-    Base class for memory mixins. In angr, all memory objects are made by
-    subclassing one or more MemoryMixins, each adding some functionality to the
-    memory object.
+    MemoryMixin is the base class for the memory model in angr. It provides a
+    set of methods that should be implemented by memory models. This is done
+    using mixins, where each mixin handles some specific feature of the memory
+    model, only overriding methods that it needs to implement its function. The
+    memory model class itself then combines a set of mixins using inheritence to
+    form the final memory model class.
     """
 
-    SUPPORTS_CONCRETE_LOAD = False
+    # pylint: disable=no-self-use,unused-argument
 
-    def __init__(self, memory_id=None, endness="Iend_BE"):
+    SUPPORTS_CONCRETE_LOAD: bool = False
+
+    def __init__(self, memory_id: str | None = None, endness: str = "Iend_BE"):
         super().__init__()
         self.id = memory_id
         self.endness = endness
 
-    def copy(self, memo):  # pylint:disable=unused-argument
+    def copy(self, memo) -> Self:
         o = type(self).__new__(type(self))
         o.id = self.id
         o.endness = self.endness
         return o
 
     @property
-    def category(self):
+    def category(self) -> str:
         """
         Return the category of this SimMemory instance. It can be one of the three following categories: reg, mem,
         or file.
         """
 
+        assert isinstance(self.id, str)
         if self.id in ("reg", "mem"):
             return self.id
 
@@ -48,46 +60,46 @@ class MemoryMixin(SimStatePlugin):
         raise SimMemoryError(f'Unknown SimMemory category for memory_id "{self.id}"')
 
     @property
-    def variable_key_prefix(self):
+    def variable_key_prefix(self) -> tuple[Any, ...]:
         s = self.category
         if s == "file":
             return (s, self.id)
         return (s,)
 
-    def find(self, addr, data, max_search, **kwargs):
-        pass
+    def find(
+        self, addr: Addr, data: InData, max_search: int, **kwargs
+    ) -> tuple[Addr, list[claripy.ast.Bool], list[int]]: ...
 
-    def _add_constraints(self, c, add_constraints=True, condition=None, **kwargs):  # pylint:disable=unused-argument
+    def _add_constraints(self, c, *, add_constraints=True, condition=None, **kwargs):
         if add_constraints:
             to_add = c & condition | ~condition if condition is not None else c
             self.state.add_constraints(to_add)
 
-    def load(self, addr, size=None, **kwargs):
-        pass
+    def load(self, addr: Addr, size: InData | None = None, **kwargs) -> OutData: ...
 
-    def store(self, addr, data, **kwargs):
-        pass
+    def store(self, addr: Addr, data: InData, size: InData | None = None, **kwargs) -> None: ...
 
-    def merge(self, others, merge_conditions, common_ancestor=None) -> bool:
-        pass
+    def merge(
+        self, others: list[Self], merge_conditions: list[claripy.ast.Bool], common_ancestor: Self | None = None
+    ) -> bool: ...
 
-    def compare(self, other) -> bool:
-        pass
+    def compare(self, other: Self) -> bool: ...
 
-    def widen(self, others):
-        pass
+    def widen(self, others: list[Self]) -> bool: ...
 
-    def permissions(self, addr, permissions=None, **kwargs):
-        pass
+    def permissions(self, addr: Addr, permissions: int | claripy.ast.BV | None = None, **kwargs) -> claripy.ast.BV: ...
 
-    def map_region(self, addr, length, permissions, init_zero=False, **kwargs):
+    def map_region(
+        self, addr: Addr, length: int, permissions: int | claripy.ast.BV, *, init_zero: bool = False, **kwargs
+    ):
         pass
 
-    def unmap_region(self, addr, length, **kwargs):
+    def unmap_region(self, addr: Addr, length: int, **kwargs):
         pass
 
     # Optional interface:
-    def concrete_load(self, addr, size, writing=False, **kwargs) -> memoryview:
+    # TODO type this correctly. maybe split the bitmap version into another function?
+    def concrete_load(self, addr, size, writing=False, **kwargs) -> Any:
         """
         Set SUPPORTS_CONCRETE_LOAD to True and implement concrete_load if reading concrete bytes is faster in this
         memory model.
@@ -99,7 +111,7 @@ class MemoryMixin(SimStatePlugin):
         """
         raise NotImplementedError
 
-    def erase(self, addr, size=None, **kwargs) -> None:
+    def erase(self, addr: Addr, size: int | None = None, **kwargs) -> None:
         """
         Set [addr:addr+size) to uninitialized. In many cases this will be faster than overwriting those locations with
         new values. This is commonly used during static data flow analysis.
@@ -110,9 +122,7 @@ class MemoryMixin(SimStatePlugin):
         """
         raise NotImplementedError
 
-    def _default_value(  # pylint:disable=too-many-positional-arguments
-        self, addr, size, name=None, inspect=True, events=True, key=None, **kwargs
-    ):
+    def _default_value(self, addr, size, *, name=None, inspect=True, events=True, key=None, **kwargs) -> OutData:
         """
         Override this method to provide default values for a variety of edge cases and base cases.
 
@@ -123,8 +133,9 @@ class MemoryMixin(SimStatePlugin):
 
         The ``inspect``, ``events``, and ``key`` parameters are for ``state.solver.Unconstrained``, if it is used.
         """
+        raise NotImplementedError
 
-    def _merge_values(self, values: Iterable[tuple[Any, Any]], merged_size: int, **kwargs) -> Any | None:
+    def _merge_values(self, values: Iterable[tuple[Any, Any]], merged_size: int, **kwargs) -> OutData | None:
         """
         Override this method to provide value merging support.
 
@@ -149,7 +160,7 @@ class MemoryMixin(SimStatePlugin):
     def _replace_all(self, addrs: Iterable[int], old: claripy.ast.BV, new: claripy.ast.BV):
         raise NotImplementedError
 
-    def copy_contents(self, dst, src, size, condition=None, **kwargs):
+    def copy_contents(self, dst: Addr, src: Addr, size: InData, condition: claripy.ast.Bool | None = None, **kwargs):
         """
         Override this method to provide faster copying of large chunks of data.