angr 9.2.122__py3-none-manylinux2014_aarch64.whl → 9.2.124__py3-none-manylinux2014_aarch64.whl

angr/engines/vex/heavy/concretizers.py

@@ -23,7 +23,7 @@ def concretize_2xm1(state, args):
     # 2xm1(x) = 2 ** x - 1. Concretize 2**x part alone since only that cannot be modelled in Z3.
     arg_x = state.solver.eval(args[1])
     if -1 <= arg_x <= 1:
-        return state.solver.FPV(math.pow(2, arg_x) - 1, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.pow(2, arg_x) - 1, claripy.FSORT_DOUBLE)
 
     # If x is outside range [-1.0, 1.0], result is undefined. We return argument itself as observed on an Intel CPU.
     return args[1]
@@ -31,26 +31,26 @@ def concretize_2xm1(state, args):
 
 def concretize_abs_float64(state, args):
     arg_val = state.solver.eval(args[0])
-    return state.solver.FPV(abs(arg_val), args[0].sort)
+    return claripy.FPV(abs(arg_val), args[0].sort)
 
 
 def concretize_add_float64(state, args):
     arg0 = state.solver.eval(args[1])
     arg1 = state.solver.eval(args[2])
-    return state.solver.FPV(arg0 + arg1, claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg0 + arg1, claripy.FSORT_DOUBLE)
 
 
 def concretize_add32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 + fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 + fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_add64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 + fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 + fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -71,18 +71,18 @@ def concretize_divf64(state, args):
     arg1 = state.solver.eval(args[1])
     arg2 = state.solver.eval(args[2])
     if arg2 == 0:
-        return state.solver.FPV(math.inf, args[1].sort)
+        return claripy.FPV(math.inf, args[1].sort)
 
-    return state.solver.FPV(arg1 / arg2, args[1].sort)
+    return claripy.FPV(arg1 / arg2, args[1].sort)
 
 
 def concretize_div32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
     if fp_arg1 == 0:
-        result = state.solver.FPV(math.inf, claripy.FSORT_FLOAT).raw_to_bv()
+        result = claripy.FPV(math.inf, claripy.FSORT_FLOAT).raw_to_bv()
     else:
-        result = state.solver.FPV(fp_arg0 / fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+        result = claripy.FPV(fp_arg0 / fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
 
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
@@ -91,21 +91,21 @@ def concretize_div64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
     if fp_arg1 == 0:
-        result = state.solver.FPV(math.inf, claripy.FSORT_DOUBLE).raw_to_bv()
+        result = claripy.FPV(math.inf, claripy.FSORT_DOUBLE).raw_to_bv()
     else:
-        result = state.solver.FPV(fp_arg0 / fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+        result = claripy.FPV(fp_arg0 / fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
 
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_float32_to_float64(state, args):
     arg0 = state.solver.eval(args[0])
-    return state.solver.FPV(arg0, claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg0, claripy.FSORT_DOUBLE)
 
 
 def concretize_float64_to_float32(state, args):
     arg = state.solver.eval(args[1])
-    return state.solver.FPV(arg, claripy.FSORT_FLOAT)
+    return claripy.FPV(arg, claripy.FSORT_FLOAT)
 
 
 def concretize_float64_to_int64s(state, args):
@@ -127,20 +127,20 @@ def concretize_int64s_to_float64(state, args):
 def concretize_mulf64(state, args):
     arg1 = state.solver.eval(args[1])
     arg2 = state.solver.eval(args[2])
-    return state.solver.FPV(arg1 / arg2, args[1].sort)
+    return claripy.FPV(arg1 / arg2, args[1].sort)
 
 
 def concretize_mul32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 * fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 * fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_mul64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 * fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 * fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -149,24 +149,24 @@ def concretize_fscale(state, args):
     arg_x = state.solver.eval(args[1])
     arg_y = math.floor(state.solver.eval(args[2]))
     if math.isnan(arg_x) or math.isnan(arg_y):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs(arg_x) == math.inf and arg_y == -1 * math.inf:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if arg_x == 0.0 and arg_y == math.inf:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(arg_x * math.pow(2, arg_y), claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg_x * math.pow(2, arg_y), claripy.FSORT_DOUBLE)
 
 
 def concretize_fsqrt(state, args):
     # Concretize floating point square root. Z3 does support square root but unsure if that includes floating point
     arg_1 = state.solver.eval(args[1])
     if arg_1 < 0 or math.isnan(arg_1):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(math.sqrt(arg_1), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.sqrt(arg_1), claripy.FSORT_DOUBLE)
 
 
 def concretize_prem(state, args):
@@ -175,7 +175,7 @@ def concretize_prem(state, args):
     dividend = state.solver.eval(args[1])
     divisor = state.solver.eval(args[2])
     if math.isnan(dividend) or math.isnan(divisor) or abs(dividend) == math.inf or divisor == 0.0:
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs(divisor) == math.inf or dividend == 0.0:
         return args[1]
@@ -194,9 +194,9 @@ def concretize_prem(state, args):
 
     if result == 0.0 and math.copysign(1.0, dividend) < 0:
         # According to Intel manual, if result is 0, its sign should be same as that of dividend.
-        return state.solver.FPV(-0.0, claripy.FSORT_DOUBLE)
+        return claripy.FPV(-0.0, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(result, claripy.FSORT_DOUBLE)
+    return claripy.FPV(result, claripy.FSORT_DOUBLE)
 
 
 def concretize_prem_flags(state, args):
@@ -241,20 +241,20 @@ def concretize_prem_flags(state, args):
 
 
 def concretize_reinterp_float64_as_int64(state, args):
-    return state.solver.FPV(state.solver.eval(args[0]), args[0].sort).raw_to_bv()
+    return claripy.FPV(state.solver.eval(args[0]), args[0].sort).raw_to_bv()
 
 
 def concretize_sub32f04(state, args):
     fp_arg0 = state.solver.eval(args[0][31:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][31:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 - fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
+    result = claripy.FPV(fp_arg0 - fp_arg1, claripy.FSORT_FLOAT).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
 def concretize_sub64f02(state, args):
     fp_arg0 = state.solver.eval(args[0][63:0].raw_to_fp())
     fp_arg1 = state.solver.eval(args[1][63:0].raw_to_fp())
-    result = state.solver.FPV(fp_arg0 - fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
+    result = claripy.FPV(fp_arg0 - fp_arg1, claripy.FSORT_DOUBLE).raw_to_bv()
     return claripy.Concat(args[0][(args[0].length - 1) : result.size()], result)
 
 
@@ -265,18 +265,18 @@ def concretize_trig_cos(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.cos(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.cos(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_trig_sin(state, args):
@@ -286,18 +286,18 @@ def concretize_trig_sin(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.sin(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.sin(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_trig_tan(state, args):
@@ -307,18 +307,18 @@ def concretize_trig_tan(state, args):
     abs_arg_x = abs(arg_x)
 
     if math.isnan(abs_arg_x):
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x == math.inf:
         # Floating-point invalid-operation exception
-        return state.solver.FPV(math.nan, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.nan, claripy.FSORT_DOUBLE)
 
     if abs_arg_x > pow(2, 63):
         # Intel manual says argument must be in range [-2^63, 2^63]. Otherwise, floating-point invalid-operation
         # exception: leave value changed
         return args[1]
 
-    return state.solver.FPV(math.tan(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(math.tan(arg_x), claripy.FSORT_DOUBLE)
 
 
 def concretize_yl2x(state, args):
@@ -330,35 +330,35 @@ def concretize_yl2x(state, args):
     arg_y = state.solver.eval(args[1])
     if arg_x < 0:
         # TODO: Indicate floating-point invalid-operation exception
-        return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+        return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
     if arg_x == 0:
         if abs(arg_y) == math.inf:
-            return state.solver.FPV(-1 * arg_y, claripy.FSORT_DOUBLE)
+            return claripy.FPV(-1 * arg_y, claripy.FSORT_DOUBLE)
         if arg_y == 0:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
         # TODO: Indicate floating-point zero-division exception
-        return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+        return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
     if arg_x == 1:
         if abs(arg_y) == math.inf:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
 
         # TODO: How to distinguish between +0 and -0?
-        return state.solver.FPV(0, claripy.FSORT_DOUBLE)
+        return claripy.FPV(0, claripy.FSORT_DOUBLE)
 
     if arg_x == math.inf:
         if arg_y == 0:
             # TODO: Indicate floating-point invalid-operation exception
-            return state.solver.FPV(arg_x, claripy.FSORT_DOUBLE)
+            return claripy.FPV(arg_x, claripy.FSORT_DOUBLE)
         if arg_y < 0:
-            return state.solver.FPV(-1 * math.inf, claripy.FSORT_DOUBLE)
+            return claripy.FPV(-1 * math.inf, claripy.FSORT_DOUBLE)
 
-        return state.solver.FPV(math.inf, claripy.FSORT_DOUBLE)
+        return claripy.FPV(math.inf, claripy.FSORT_DOUBLE)
 
-    return state.solver.FPV(arg_y * math.log2(arg_x), claripy.FSORT_DOUBLE)
+    return claripy.FPV(arg_y * math.log2(arg_x), claripy.FSORT_DOUBLE)
 
 
 concretizers = {

angr/engines/vex/heavy/dirty.py

@@ -19,12 +19,12 @@ l = logging.getLogger(name=__name__)
 # http://www-inteng.fnal.gov/Integrated_Eng/GoodwinDocs/pdf/Sys%20docs/PowerPC/PowerPC%20Elapsed%20Time.pdf
 # and
 # http://www.cap-lore.com/code/TB/
-def ppcg_dirtyhelper_MFTB(state):
+def ppcg_dirtyhelper_MFTB(state):  # pylint:disable=unused-argument
     # TODO: This is an incorrect implementation. Fix it later!
     return claripy.BVV(0x200, 64), []
 
 
-def ppc32g_dirtyhelper_MFSPR_287(state):
+def ppc32g_dirtyhelper_MFSPR_287(state):  # pylint:disable=unused-argument
     return claripy.BVV(0x200, 32), []
 
 
@@ -119,8 +119,8 @@ EmWarn_S390X_fpext_rounding = 10
 EmWarn_S390X_invalid_rounding = 11
 
 
-def amd64g_check_ldmxcsr(state, mxcsr):
-    rmode = state.solver.LShR(mxcsr, 13) & 3
+def amd64g_check_ldmxcsr(state, mxcsr):  # pylint:disable=unused-argument
+    rmode = claripy.LShR(mxcsr, 13) & 3
 
     ew = claripy.If(
         (mxcsr & 0x1F80) != 0x1F80,

angr/knowledge_plugins/__init__.py

@@ -17,6 +17,7 @@ from .structured_code import StructuredCodeManager
 from .types import TypesStore
 from .callsite_prototypes import CallsitePrototypes
 from .custom_strings import CustomStrings
+from .decompilation import DecompilationManager
 
 
 __all__ = (
@@ -38,4 +39,5 @@ __all__ = (
     "TypesStore",
     "CallsitePrototypes",
     "CustomStrings",
+    "DecompilationManager",
 )

angr/knowledge_plugins/decompilation.py

@@ -0,0 +1,45 @@
+# pylint:disable=import-outside-toplevel
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+from .plugin import KnowledgeBasePlugin
+
+if TYPE_CHECKING:
+    from angr.analyses.decompiler.decompilation_cache import DecompilationCache
+
+
+class DecompilationManager(KnowledgeBasePlugin):
+    """A knowledge base plugin to store decompilation results."""
+
+    def __init__(self, kb):
+        super().__init__(kb=kb)
+        self.cached: dict[Any, DecompilationCache] = {}
+
+    def _normalize_key(self, item: int | str):
+        if type(item) is str:
+            item = (self._kb.labels.lookup(item[0]), *item[1:])
+        return item
+
+    def __getitem__(self, item) -> DecompilationCache:
+        return self.cached[self._normalize_key(item)]
+
+    def __setitem__(self, key, value: DecompilationCache):
+        self.cached[self._normalize_key(key)] = value
+
+    def __contains__(self, key):
+        return self._normalize_key(key) in self.cached
+
+    def __delitem__(self, key):
+        del self.cached[self._normalize_key(key)]
+
+    def discard(self, key):
+        normalized_key = self._normalize_key(key)
+        if normalized_key in self.cached:
+            del self.cached[normalized_key]
+
+    def copy(self):
+        raise NotImplementedError
+
+
+KnowledgeBasePlugin.register_default("decompilations", DecompilationManager)

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/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/procedures/java_lang/getsimplename.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
+
 import logging
 
+import claripy
+
 from angr.procedures.java import JavaSimProcedure
 from angr.engines.soot.values.strref import SimSootValue_StringRef
 
@@ -12,4 +15,4 @@ class GetSimpleName(JavaSimProcedure):
 
     def run(self, this):  # pylint: disable=arguments-differ
         class_simple_name = this.type.split(".")[-1]
-        return SimSootValue_StringRef.new_string(self.state, self.state.solver.StringV(class_simple_name))
+        return SimSootValue_StringRef.new_string(self.state, claripy.StringV(class_simple_name))

angr/procedures/linux_kernel/iovec.py

@@ -1,4 +1,7 @@
 from __future__ import annotations
+
+import claripy
+
 import angr
 from angr.procedures.posix.read import read
 from angr.procedures.posix.write import write
@@ -24,7 +27,7 @@ class readv(angr.SimProcedure):
         res = 0
         for element in self.state.mem[iovec].struct.iovec.array(iovcnt).resolved:
             tmpres = self.inline_call(read, fd, element.iov_base, element.iov_len).ret_expr
-            if self.state.solver.is_true(self.state.solver.SLT(tmpres, 0)):
+            if self.state.solver.is_true(claripy.SLT(tmpres, 0)):
                 return tmpres
 
         return res
@@ -38,7 +41,7 @@ class writev(angr.SimProcedure):
         res = 0
         for element in self.state.mem[iovec].struct.iovec.array(iovcnt).resolved:
             tmpres = self.inline_call(write, fd, element.iov_base, element.iov_len).ret_expr
-            if self.state.solver.is_true(self.state.solver.SLT(tmpres, 0)):
+            if self.state.solver.is_true(claripy.SLT(tmpres, 0)):
                 return tmpres
 
         return res

angr/sim_type.py

@@ -1629,7 +1629,9 @@ class SimUnion(NamedTypeMixin, SimType):
 
     @property
     def size(self):
-        return max(ty.size for ty in self.members.values() if not isinstance(ty, SimTypeBottom))
+        member_sizes = [ty.size for ty in self.members.values() if not isinstance(ty, SimTypeBottom)]
+        # fall back to word size in case all members are SimTypeBottom
+        return max(member_sizes) if member_sizes else self._arch.bytes
 
     @property
     def alignment(self):

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)