angr 9.2.123__py3-none-manylinux2014_x86_64.whl → 9.2.124__py3-none-manylinux2014_x86_64.whl

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.
 

angr/storage/memory_mixins/paged_memory/page_backer_mixins.py

@@ -7,8 +7,6 @@ import logging
 import claripy
 import cle
 
-from .paged_memory_mixin import PagedMemoryMixin
-
 l = logging.getLogger(__name__)
 
 BackerType = Union[bytes, bytearray, list[int]]
@@ -29,6 +27,9 @@ class NotMemoryview:
         memoryview(self.obj)[self.offset : self.offset + self.size][k] = v
 
 
+from .paged_memory_mixin import PagedMemoryMixin
+
+
 class ClemoryBackerMixin(PagedMemoryMixin):
     def __init__(self, cle_memory_backer: None | cle.Loader | cle.Clemory = None, **kwargs):
         super().__init__(**kwargs)
@@ -49,9 +50,9 @@ class ClemoryBackerMixin(PagedMemoryMixin):
         o._cle_loader = self._cle_loader
         return o
 
-    def _initialize_page(self, pageno, force_default=False, **kwargs):
+    def _initialize_page(self, pageno, permissions=None, *, force_default=False, **kwargs):
         if self._clemory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         addr = pageno * self.page_size
 
@@ -59,10 +60,10 @@ class ClemoryBackerMixin(PagedMemoryMixin):
             backer_iter: BackerIterType = self._clemory_backer.backers(addr)
             backer_start, backer = next(backer_iter)
         except StopIteration:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if backer_start >= addr + self.page_size:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         # Load data from backere
         data = self._data_from_backer(addr, backer, backer_start, backer_iter)
@@ -184,9 +185,9 @@ class ClemoryBackerMixin(PagedMemoryMixin):
 
 
 class ConcreteBackerMixin(ClemoryBackerMixin):
-    def _initialize_page(self, pageno, force_default=False, **kwargs):
+    def _initialize_page(self, pageno, permissions=None, *, force_default=False, **kwargs):
         if self._clemory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         addr = pageno * self.page_size
 
@@ -194,10 +195,10 @@ class ConcreteBackerMixin(ClemoryBackerMixin):
             backer_iter = self._clemory_backer.backers(addr)
             backer_start, backer = next(backer_iter)
         except StopIteration:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if backer_start >= addr + self.page_size:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if self.state.project.concrete_target:
             l.debug("Fetching data from concrete target")
@@ -207,7 +208,7 @@ class ConcreteBackerMixin(ClemoryBackerMixin):
             )
         else:
             # the concrete backer only is here to support concrete loading, defer back to the CleMemoryBacker
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         permissions = self._cle_permissions_lookup(addr)
 
@@ -237,11 +238,11 @@ class DictBackerMixin(PagedMemoryMixin):
         o._dict_memory_backer = self._dict_memory_backer
         return o
 
-    def _initialize_page(self, pageno: int, force_default=False, **kwargs):
+    def _initialize_page(self, pageno: int, permissions=None, *, force_default=False, **kwargs):
         page_addr = pageno * self.page_size
 
         if self._dict_memory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         new_page = None
 
@@ -261,6 +262,6 @@ class DictBackerMixin(PagedMemoryMixin):
                 )
 
         if new_page is None:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         return new_page

angr/storage/memory_mixins/paged_memory/paged_memory_mixin.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 import cffi
-from typing import Any
+from typing import Any, Generic, Literal, overload
 from collections.abc import Iterable
 import logging
 from collections import defaultdict
 
 import claripy
 
+from angr.state_plugins.sim_action_object import SimActionObject
 from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 from angr.storage.memory_mixins.paged_memory.pages import PageType, ListPage, UltraPage, MVListPage
 from angr.errors import SimMemoryError
@@ -17,14 +18,17 @@ ffi = cffi.FFI()
 l = logging.getLogger(__name__)
 
 
-class PagedMemoryMixin(MemoryMixin):
+class PagedMemoryMixin(
+    Generic[PageType],
+    MemoryMixin[int | claripy.ast.BV | SimActionObject, claripy.ast.BV, int | claripy.ast.BV | SimActionObject],
+):
     """
     A bottom-level storage mechanism. Dispatches reads to individual pages, the type of which is the PAGE_TYPE class
     variable.
     """
 
     SUPPORTS_CONCRETE_LOAD = True
-    PAGE_TYPE: type[PageType] = None  # must be provided in subclass
+    PAGE_TYPE: type[PageType]  # must be provided in subclass
 
     def __init__(self, page_size=0x1000, default_permissions=3, permissions_map=None, page_kwargs=None, **kwargs):
         super().__init__(**kwargs)
@@ -84,7 +88,7 @@ class PagedMemoryMixin(MemoryMixin):
         kwargs["allow_default"] = True
         return PagedMemoryMixin._initialize_page(self, pageno, permissions=permissions, **kwargs)
 
-    def _initialize_page(self, pageno: int, permissions=None, allow_default=True, **kwargs) -> PageType:
+    def _initialize_page(self, pageno: int, permissions=None, *, allow_default=True, **kwargs) -> PageType:
         if not allow_default:
             raise SimMemoryError("I have been instructed not to create a default page")
 
@@ -110,7 +114,7 @@ class PagedMemoryMixin(MemoryMixin):
     def _divide_addr(self, addr: int) -> tuple[int, int]:
         return divmod(addr, self.page_size)
 
-    def load(self, addr: int, size: int | None = None, endness=None, **kwargs):
+    def load(self, addr: int, size: int | None = None, *, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -164,7 +168,7 @@ class PagedMemoryMixin(MemoryMixin):
         l.debug("%s.load(%#x, %d, %s) = %s", self.id, addr, size, endness, out)
         return out
 
-    def store(self, addr: int, data, size: int | None = None, endness=None, **kwargs):
+    def store(self, addr: int, data, size: int | None = None, *, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -253,7 +257,7 @@ class PagedMemoryMixin(MemoryMixin):
             pageno = (pageno + 1) % max_pageno
             pageoff = 0
 
-    def merge(self, others: Iterable[PagedMemoryMixin], merge_conditions, common_ancestor=None) -> bool:
+    def merge(self, others, merge_conditions, common_ancestor=None):
         changed_pages_and_offsets: dict[int, set[int] | None] = {}
         for o in others:
             for changed_page, changed_offsets in self.changed_pages(o).items():
@@ -315,7 +319,7 @@ class PagedMemoryMixin(MemoryMixin):
         return True
 
     def permissions(self, addr, permissions=None, **kwargs):
-        if type(addr) is not int:
+        if not isinstance(addr, int):
             raise TypeError("addr must be an int in paged memory")
         pageno, _ = self._divide_addr(addr)
         try:
@@ -323,15 +327,15 @@ class PagedMemoryMixin(MemoryMixin):
         except SimMemoryError as e:
             raise SimMemoryError(f"{addr:#x} is not mapped") from e
 
-        if type(permissions) is int:
+        if isinstance(permissions, int):
             permissions = claripy.BVV(permissions, 3)
 
-        result = page.permissions
+        result = page.permission_bits
         if permissions is not None:
-            page.permissions = permissions
+            page.permission_bits = permissions
         return result
 
-    def map_region(self, addr, length, permissions, init_zero=False, **kwargs):
+    def map_region(self, addr, length, permissions, *, init_zero=False, **kwargs):
         if type(addr) is not int:
             raise TypeError("addr must be an int in paged memory")
         pageno, pageoff = self._divide_addr(addr)
@@ -399,6 +403,11 @@ class PagedMemoryMixin(MemoryMixin):
         else:
             return True
 
+    @overload
+    def _load_to_memoryview(self, addr, size, with_bitmap: Literal[True]) -> tuple[memoryview, memoryview]: ...
+    @overload
+    def _load_to_memoryview(self, addr, size, with_bitmap: Literal[False]) -> memoryview: ...
+
     def _load_to_memoryview(self, addr, size, with_bitmap):
         result = self.load(addr, size, endness="Iend_BE")
         if result.op == "BVV":
@@ -469,7 +478,7 @@ class PagedMemoryMixin(MemoryMixin):
             return memoryview(bytes(size)), memoryview(b"\x01" * size)
         return memoryview(b"")
 
-    def concrete_load(self, addr, size, writing=False, with_bitmap=False, **kwargs):
+    def concrete_load(self, addr, size, writing=False, *, with_bitmap: bool = False, **kwargs):
         pageno, offset = self._divide_addr(addr)
         subsize = min(size, self.page_size - offset)
         try:
@@ -481,9 +490,11 @@ class PagedMemoryMixin(MemoryMixin):
 
         if not page.SUPPORTS_CONCRETE_LOAD:
             # the page does not support concrete_load
-            return self._load_to_memoryview(addr, size, with_bitmap)
+            if with_bitmap:
+                return self._load_to_memoryview(addr, size, True)
+            return self._load_to_memoryview(addr, size, False)
 
-        data, bitmap = page.concrete_load(offset, subsize, **kwargs)
+        data, bitmap = page.concrete_load(offset, subsize, with_bitmap=True, **kwargs)
         if with_bitmap:
             return data, bitmap
 
@@ -513,7 +524,7 @@ class PagedMemoryMixin(MemoryMixin):
             except (SimMemoryError, AttributeError):
                 break
             else:
-                newdata, bitmap = concrete_load(offset, subsize, **kwargs)
+                newdata, bitmap = concrete_load(offset, subsize, with_bitmap=True, **kwargs)
                 for i, byte in enumerate(bitmap):
                     if byte != 0:
                         break

angr/storage/memory_mixins/paged_memory/pages/cooperation.py

@@ -1,26 +1,32 @@
 from __future__ import annotations
-from typing import Any
+from abc import abstractmethod
+from typing import Generic, TypeVar
+from collections.abc import Generator
 
 import claripy
 
 from angr.storage.memory_object import SimMemoryObject, SimLabeledMemoryObject
 from .multi_values import MultiValues
 
+T = TypeVar("T")
 
-class CooperationBase:
+
+class CooperationBase(Generic[T]):
     """
     Any given subclass of this class which is not a subclass of MemoryMixin should have the property that any subclass
     it which *is* a subclass of MemoryMixin should all work with the same datatypes
     """
 
     @classmethod
-    def _compose_objects(cls, objects, size, endness, **kwargs):
+    @abstractmethod
+    def _compose_objects(cls, objects: list[list[tuple[int, T]]], size: str, endness: str, **kwargs) -> T:
         """
         Provide this a list of the result of several load calls, and it will compose them into a single result.
         """
 
     @classmethod
-    def _decompose_objects(cls, addr, data, endness, **kwargs) -> tuple[Any, int, int]:
+    @abstractmethod
+    def _decompose_objects(cls, addr, data, endness, **kwargs) -> Generator[tuple[T, int, int], int]:
         """
         A bidirectional generator. No idea if this is overengineered. Usage is that you send it a size to use
         and it yields a tuple of three elements: the object to store for the next n bytes, the base address of the
@@ -28,13 +34,14 @@ class CooperationBase:
         """
 
     @classmethod
-    def _zero_objects(cls, addr, size, **kwargs):
+    @abstractmethod
+    def _zero_objects(cls, addr, size, **kwargs) -> Generator[tuple[T, int, int], int]:
         """
         Like decompose objects, but with a size to zero-fill instead of explicit data
         """
 
     @classmethod
-    def _force_store_cooperation(cls, addr, data, size, endness, **kwargs):
+    def _force_store_cooperation(cls, addr: int, data: T, size: int, endness: str, **kwargs):
         if data is not None:
             sub_gen = cls._decompose_objects(addr, data, endness, **kwargs)
         else:
@@ -50,7 +57,7 @@ class CooperationBase:
         return cls._compose_objects([results], size, endness, **kwargs)
 
 
-class MemoryObjectMixin(CooperationBase):
+class MemoryObjectMixin(CooperationBase[SimMemoryObject]):
     """
     Uses SimMemoryObjects in region storage.
     With this, load will return a list of tuple (address, MO) and store will take a MO.
@@ -123,11 +130,12 @@ class MemoryObjectMixin(CooperationBase):
         else:
             memory_object = SimLabeledMemoryObject(data, cur_addr, endness, byte_width=byte_width, label=label)
 
+        next_elem_size_left = 0
+        next_elem_index = 0
         if data.symbolic and data.op == "Concat":
             next_elem_size_left = data.args[0].size() // 8
-            next_elem_index = 0
 
-        size = yield
+        size = yield NotImplemented, NotImplemented, NotImplemented
         max_size = kwargs.get("max_size", size)
         while True:
             if data.symbolic and data.op == "Concat" and data.size() > max_size:
@@ -235,6 +243,7 @@ class MemoryObjectSetMixin(CooperationBase):
             mv.add_value(start_offset, prev_value)
             prev_value = ...
 
+        assert next(mv.values(), None) is not None, "MultiValues may not be empty"
         return mv
 
     @classmethod

angr/storage/memory_mixins/paged_memory/pages/ispo_mixin.py

@@ -14,7 +14,7 @@ class ISPOMixin(MemoryMixin):
     def set_state(self, state):
         raise Exception("Cannot set state on this stateless object")
 
-    def _default_value(self, *args, memory=None, **kwargs):
+    def _default_value(self, *args, memory, **kwargs):
         try:
             func = memory._default_value
         except AttributeError as e:
@@ -22,7 +22,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _add_constraints(self, *args, memory=None, **kwargs):
+    def _add_constraints(self, *args, memory, **kwargs):
         try:
             func = memory._add_constraints
         except AttributeError as e:
@@ -30,7 +30,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _merge_values(self, *args, memory=None, **kwargs):
+    def _merge_values(self, *args, memory, **kwargs):
         try:
             func = memory._merge_values
         except AttributeError as ex:
@@ -38,7 +38,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _merge_labels(self, *args, memory=None, **kwargs):
+    def _merge_labels(self, *args, memory, **kwargs):
         try:
             func = memory._merge_labels
         except AttributeError as ex:
@@ -46,7 +46,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _update_mappings(self, *args, memory=None, **kwargs):
+    def _update_mappings(self, *args, memory, **kwargs):
         try:
             func = memory._update_mappings
         except AttributeError as ex: