angr 9.2.116__py3-none-manylinux2014_x86_64.whl → 9.2.118__py3-none-manylinux2014_x86_64.whl

angr/procedures/libc/strncmp.py

@@ -1,7 +1,10 @@
-import angr
-
+from __future__ import annotations
 import logging
 
+import claripy
+
+import angr
+
 l = logging.getLogger(name=__name__)
 
 
@@ -50,9 +53,9 @@ class strncmp(angr.SimProcedure):
                 maxlen = max(a_strlen.max_null_index, b_strlen.max_null_index)
 
             match_constraints.append(
-                self.state.solver.Or(
+                claripy.Or(
                     a_len == b_len,
-                    self.state.solver.And(self.state.solver.UGE(a_len, limit), self.state.solver.UGE(b_len, limit)),
+                    claripy.And(claripy.UGE(a_len, limit), claripy.UGE(b_len, limit)),
                 )
             )
 
@@ -62,22 +65,20 @@ class strncmp(angr.SimProcedure):
             if self.state.solver.single_valued(limit) and self.state.solver.eval(limit) == 0:
                 # limit is 0
                 l.debug("returning equal for 0-limit")
-                return self.state.solver.BVV(0, 32)
-            elif (
+                return claripy.BVV(0, 32)
+            if (
                 self.state.solver.single_valued(a_len)
                 and self.state.solver.single_valued(b_len)
                 and self.state.solver.eval(a_len) == self.state.solver.eval(b_len) == 0
             ):
                 # two empty strings
                 l.debug("returning equal for two empty strings")
-                return self.state.solver.BVV(0, 32)
-            else:
-                # all other cases fall into this branch
-                l.debug("returning non-equal for comparison of an empty string and a non-empty string")
-                if a_strlen.max_null_index == 0:
-                    return self.state.solver.BVV(-1, 32)
-                else:
-                    return self.state.solver.BVV(1, 32)
+                return claripy.BVV(0, 32)
+            # all other cases fall into this branch
+            l.debug("returning non-equal for comparison of an empty string and a non-empty string")
+            if a_strlen.max_null_index == 0:
+                return claripy.BVV(-1, 32)
+            return claripy.BVV(1, 32)
 
         # the bytes
         max_byte_len = maxlen * char_size
@@ -109,11 +110,10 @@ class strncmp(angr.SimProcedure):
                         b_conc -= ord(" ")
 
                 if a_conc != b_conc:
-                    l.debug("... found mis-matching concrete bytes 0x%x and 0x%x", a_conc, b_conc)
+                    l.debug("... found mismatching concrete bytes 0x%x and 0x%x", a_conc, b_conc)
                     if a_conc < b_conc:
-                        return self.state.solver.BVV(-1, 32)
-                    else:
-                        return self.state.solver.BVV(1, 32)
+                        return claripy.BVV(-1, 32)
+                    return claripy.BVV(1, 32)
             else:
                 if self.state.mode == "static":
                     return_values.append(a_byte - b_byte)
@@ -122,17 +122,17 @@ class strncmp(angr.SimProcedure):
 
             if self.state.mode != "static":
                 if ignore_case:
-                    byte_constraint = self.state.solver.Or(
-                        self.state.solver.Or(
+                    byte_constraint = claripy.Or(
+                        claripy.Or(
                             a_byte == b_byte,
-                            self.state.solver.And(
+                            claripy.And(
                                 ord("A") <= a_byte,
                                 a_byte <= ord("Z"),
                                 ord("a") <= b_byte,
                                 b_byte <= ord("z"),
                                 b_byte - ord(" ") == a_byte,
                             ),
-                            self.state.solver.And(
+                            claripy.And(
                                 ord("A") <= b_byte,
                                 b_byte <= ord("Z"),
                                 ord("a") <= a_byte,
@@ -140,21 +140,19 @@ class strncmp(angr.SimProcedure):
                                 a_byte - ord(" ") == b_byte,
                             ),
                         ),
-                        self.state.solver.ULT(a_len, i),
-                        self.state.solver.ULE(limit, i),
+                        claripy.ULT(a_len, i),
+                        claripy.ULE(limit, i),
                     )
                 else:
-                    byte_constraint = self.state.solver.Or(
-                        a_byte == b_byte, self.state.solver.ULT(a_len, i), self.state.solver.ULE(limit, i)
-                    )
+                    byte_constraint = claripy.Or(a_byte == b_byte, claripy.ULT(a_len, i), claripy.ULE(limit, i))
                 match_constraints.append(byte_constraint)
 
         if concrete_run:
             l.debug("concrete run made it to the end!")
-            return self.state.solver.BVV(0, 32)
+            return claripy.BVV(0, 32)
 
         if self.state.mode == "static":
-            ret_expr = self.state.solver.ESI(8)
+            ret_expr = claripy.ESI(8)
             for expr in return_values:
                 ret_expr = ret_expr.union(expr)
 
@@ -164,17 +162,17 @@ class strncmp(angr.SimProcedure):
             # make the constraints
 
             l.debug("returning symbolic")
-            match_constraint = self.state.solver.And(*match_constraints)
-            nomatch_constraint = self.state.solver.Not(match_constraint)
+            match_constraint = claripy.And(*match_constraints)
+            nomatch_constraint = claripy.Not(match_constraint)
 
             # l.debug("match constraints: %s", match_constraint)
             # l.debug("nomatch constraints: %s", nomatch_constraint)
 
-            match_case = self.state.solver.And(limit != 0, match_constraint, ret_expr == 0)
-            nomatch_case = self.state.solver.And(limit != 0, nomatch_constraint, ret_expr == 1)
-            l0_case = self.state.solver.And(limit == 0, ret_expr == 0)
-            empty_case = self.state.solver.And(a_strlen.ret_expr == 0, b_strlen.ret_expr == 0, ret_expr == 0)
+            match_case = claripy.And(limit != 0, match_constraint, ret_expr == 0)
+            nomatch_case = claripy.And(limit != 0, nomatch_constraint, ret_expr == 1)
+            l0_case = claripy.And(limit == 0, ret_expr == 0)
+            empty_case = claripy.And(a_strlen.ret_expr == 0, b_strlen.ret_expr == 0, ret_expr == 0)
 
-            self.state.add_constraints(self.state.solver.Or(match_case, nomatch_case, l0_case, empty_case))
+            self.state.add_constraints(claripy.Or(match_case, nomatch_case, l0_case, empty_case))
 
         return ret_expr

angr/procedures/libc/strncpy.py

@@ -1,6 +1,10 @@
-import angr
+from __future__ import annotations
 import logging
 
+import claripy
+
+import angr
+
 l = logging.getLogger(name=__name__)
 
 
@@ -12,7 +16,7 @@ class strncpy(angr.SimProcedure):
         memcpy = angr.SIM_PROCEDURES["libc"]["memcpy"]
 
         src_len = src_len if src_len is not None else self.inline_call(strlen, src_addr).ret_expr
-        cpy_size = self.state.solver.If(self.state.solver.ULE(limit, src_len + 1), limit, src_len + 1)
+        cpy_size = claripy.If(claripy.ULE(limit, src_len + 1), limit, src_len + 1)
 
         self.inline_call(memcpy, dst_addr, src_addr, cpy_size)
         return dst_addr

angr/procedures/libc/strnlen.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 import logging
 
@@ -9,5 +10,4 @@ class strnlen(angr.SimProcedure):
         strlen = angr.SIM_PROCEDURES["libc"]["strlen"]
 
         maxlen = self.state.solver.eval_one(n)
-        length = self.inline_call(strlen, s, maxlen=maxlen).ret_expr
-        return length
+        return self.inline_call(strlen, s, maxlen=maxlen).ret_expr

angr/procedures/libc/strstr.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+import logging
+
+import claripy
+
 import angr
 from angr.sim_options import MEMORY_CHUNK_INDIVIDUAL_READS
 
-import logging
 
 l = logging.getLogger(name=__name__)
 
@@ -25,9 +29,9 @@ class strstr(angr.SimProcedure):
         if needle_maxlen == 0:
             l.debug("... zero-length needle.")
             return haystack_addr
-        elif haystack_maxlen == 0:
+        if haystack_maxlen == 0:
             l.debug("... zero-length haystack.")
-            return self.state.solver.BVV(0, self.state.arch.bits)
+            return claripy.BVV(0, self.state.arch.bits)
 
         if self.state.solver.symbolic(needle_strlen.ret_expr):
             cases = [[needle_strlen.ret_expr == 0, haystack_addr]]
@@ -49,11 +53,14 @@ class strstr(angr.SimProcedure):
                     b_len=needle_strlen,
                 )
 
-                c = self.state.solver.And(
+                c = claripy.And(
                     *(
-                        [self.state.solver.UGE(haystack_strlen.ret_expr, needle_strlen.ret_expr), cmp_res.ret_expr == 0]
-                        + not_terminated_yet_constraints
-                        + exclusions
+                        [
+                            claripy.UGE(haystack_strlen.ret_expr, needle_strlen.ret_expr),
+                            cmp_res.ret_expr == 0,
+                            *not_terminated_yet_constraints,
+                            *exclusions,
+                        ]
                     )
                 )
 
@@ -69,10 +76,10 @@ class strstr(angr.SimProcedure):
                     l.debug("... exhausted remaining symbolic checks.")
                     break
 
-            cases.append([self.state.solver.And(*exclusions), self.state.solver.BVV(0, self.state.arch.bits)])
+            cases.append([claripy.And(*exclusions), claripy.BVV(0, self.state.arch.bits)])
             l.debug("... created %d cases", len(cases))
-            r = self.state.solver.ite_cases(cases, 0)
-            c = [self.state.solver.Or(*[c for c, _ in cases])]
+            r = claripy.ite_cases(cases, 0)
+            c = [claripy.Or(*[c for c, _ in cases])]
         else:
             needle_length = self.state.solver.eval(needle_strlen.ret_expr)
             needle_str = self.state.memory.load(needle_addr, needle_length)

angr/procedures/libc/strtol.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 import claripy
 import logging
@@ -32,7 +33,7 @@ class strtol(angr.SimProcedure):
         # order matters here since we will use an if then else tree, and -0x will have precedence over -
         prefixes = [b"-", b"+", b""]
         if base == 16:
-            prefixes = [b"0x", b"-0x", b"+0x"] + prefixes
+            prefixes = [b"0x", b"-0x", b"+0x", *prefixes]
 
         cases = []
         conditions = []
@@ -49,9 +50,9 @@ class strtol(angr.SimProcedure):
             possible_num_bytes.append(num_bytes)
 
         # only one of the cases needed to match
-        result = state.solver.ite_cases(cases[:-1], cases[-1][1])
-        expression = state.solver.Or(*conditions)
-        num_bytes = state.solver.ite_cases(zip(conditions, possible_num_bytes), 0)
+        result = claripy.ite_cases(cases[:-1], cases[-1][1])
+        expression = claripy.Or(*conditions)
+        num_bytes = claripy.ite_cases(zip(conditions, possible_num_bytes), 0)
         return expression, result, num_bytes
 
     @staticmethod
@@ -66,12 +67,12 @@ class strtol(angr.SimProcedure):
         # the prefix must match
         if len(prefix) > 0:
             loaded_prefix = region.load(addr, length)
-            condition = state.solver.And(loaded_prefix == state.solver.BVV(prefix), condition)
+            condition = claripy.And(loaded_prefix == claripy.BVV(prefix), condition)
         total_num_bytes = num_bytes + length
 
         # negatives
         if prefix.startswith(b"-"):
-            value = state.solver.BVV(0, state.arch.bits) - value
+            value = claripy.BVV(0, state.arch.bits) - value
         return condition, value, total_num_bytes
 
     @staticmethod
@@ -92,8 +93,8 @@ class strtol(angr.SimProcedure):
 
         # to detect overflows we keep it in a larger bv and extract it at the end
         num_bits = min(state.arch.bits * 2, 128)
-        current_val = state.solver.BVV(0, num_bits)
-        num_bytes = state.solver.BVS("num_bytes", state.arch.bits)
+        current_val = claripy.BVV(0, num_bits)
+        num_bytes = claripy.BVS("num_bytes", state.arch.bits)
         # constarints_num_bytes: a series of constraints of the form:
         # AND(<constraint on the string guaranteeing that the number of digits is n>, num_bytes == n)
         # these will be combined via OR and added to the state together num_bytes and the string
@@ -115,8 +116,8 @@ class strtol(angr.SimProcedure):
             # identify the constraints necessary to set num_bytes to the current value
             # the current char (i.e. the terminator if this is satisfied) should not be a char,
             # so `condition` should be false, plus all the previous conditions should be satisfied
-            case_constraints = conditions + [state.solver.Not(condition), num_bytes == i]
-            constraints_num_bytes.append(state.solver.And(*case_constraints))
+            case_constraints = [*conditions, claripy.Not(condition), num_bytes == i]
+            constraints_num_bytes.append(claripy.And(*case_constraints))
 
             # break the loop early if no value past this is viable
             if condition.is_false():
@@ -130,19 +131,19 @@ class strtol(angr.SimProcedure):
         # if we ran out of bytes, we still need to add the case that every single byte was a digit
         if not cutoff:
             cases.append((num_bytes == length, current_val))
-            case_constraints = conditions + [num_bytes == length]
+            case_constraints = [*conditions, num_bytes == length]
             if read_length is None:
                 # the loop broke because we hit angr's coded max. we need to assert that the following char is not
                 # a digit in order for this case to generate correct models
                 char = region.load(s + length, 1)
                 condition, _ = strtol._char_to_val(char, base)
-                case_constraints.append(state.solver.Not(condition))
-            constraints_num_bytes.append(state.solver.And(*case_constraints))
+                case_constraints.append(claripy.Not(condition))
+            constraints_num_bytes.append(claripy.And(*case_constraints))
 
         # only one of the constraints need to hold
         # since the constraints look like (num_bytes == 2 and the first 2 chars are valid, and the 3rd isn't)
 
-        final_constraint = state.solver.Or(*constraints_num_bytes)
+        final_constraint = claripy.Or(*constraints_num_bytes)
         if (
             final_constraint.op == "__eq__"
             and final_constraint.args[0] is num_bytes
@@ -154,15 +155,15 @@ class strtol(angr.SimProcedure):
         else:
             # symbolic case
             state.add_constraints(final_constraint)
-            result = state.solver.ite_cases(cases, 0)
+            result = claripy.ite_cases(cases, 0)
 
         # overflow check
         max_bits = state.arch.bits - 1 if signed else state.arch.bits
         max_val = 2**max_bits - 1
-        result = state.solver.If(
+        result = claripy.If(
             result < max_val,
-            state.solver.Extract(state.arch.bits - 1, 0, result),
-            state.solver.BVV(max_val, state.arch.bits),
+            claripy.Extract(state.arch.bits - 1, 0, result),
+            claripy.BVV(max_val, state.arch.bits),
         )
 
         return expression, result, num_bytes
@@ -215,22 +216,20 @@ class strtol(angr.SimProcedure):
         if base == 0:
             # in this case the base is 16 if it starts with 0x, 8 if it starts with 0, 10 otherwise
             # here's the possibilities
-            base_16_pred = self.state.solver.Or(
-                self.state.memory.load(nptr, 2) == self.state.solver.BVV(b"0x"),
-                self.state.memory.load(nptr, 3) == self.state.solver.BVV(b"+0x"),
-                self.state.memory.load(nptr, 3) == self.state.solver.BVV(b"-0x"),
+            base_16_pred = claripy.Or(
+                self.state.memory.load(nptr, 2) == claripy.BVV(b"0x"),
+                self.state.memory.load(nptr, 3) == claripy.BVV(b"+0x"),
+                self.state.memory.load(nptr, 3) == claripy.BVV(b"-0x"),
             )
-            base_8_pred = self.state.solver.And(
-                self.state.solver.Or(
-                    self.state.memory.load(nptr, 1) == self.state.solver.BVV(b"0"),
-                    self.state.memory.load(nptr, 2) == self.state.solver.BVV(b"+0"),
-                    self.state.memory.load(nptr, 2) == self.state.solver.BVV(b"-0"),
+            base_8_pred = claripy.And(
+                claripy.Or(
+                    self.state.memory.load(nptr, 1) == claripy.BVV(b"0"),
+                    self.state.memory.load(nptr, 2) == claripy.BVV(b"+0"),
+                    self.state.memory.load(nptr, 2) == claripy.BVV(b"-0"),
                 ),
-                self.state.solver.Not(base_16_pred),
-            )
-            base_10_pred = self.state.solver.And(
-                self.state.solver.Not(base_16_pred), self.state.solver.Not(base_8_pred)
+                claripy.Not(base_16_pred),
             )
+            base_10_pred = claripy.And(claripy.Not(base_16_pred), claripy.Not(base_8_pred))
             expressions = []
             values = []
             num_bytes_arr = []
@@ -239,15 +238,15 @@ class strtol(angr.SimProcedure):
             pred_base = zip([base_16_pred, base_10_pred, base_8_pred], [16, 10, 8])
             for pred, sub_base in pred_base:
                 expression, value, num_bytes = self.strtol_inner(nptr, self.state, self.state.memory, sub_base, True)
-                expressions.append(self.state.solver.And(expression, pred))
+                expressions.append(claripy.And(expression, pred))
                 values.append(value)
                 num_bytes_arr.append(num_bytes)
 
             # we would return the Or(expressions) as the indicator whether or not it succeeded, but it's not needed
             # for strtol
-            # expression = self.state.solver.Or(expressions)
-            value = self.state.solver.ite_cases(zip(expressions, values), 0)
-            num_bytes = self.state.solver.ite_cases(zip(expressions, num_bytes_arr), 0)
+            # expression = claripy.Or(expressions)
+            value = claripy.ite_cases(zip(expressions, values), 0)
+            num_bytes = claripy.ite_cases(zip(expressions, num_bytes_arr), 0)
 
             self.state.memory.store(
                 endptr, nptr + num_bytes, condition=(endptr != 0), endness=self.state.arch.memory_endness
@@ -255,9 +254,8 @@ class strtol(angr.SimProcedure):
 
             return value
 
-        else:
-            expression, value, num_bytes = self.strtol_inner(nptr, self.state, self.state.memory, base, True)
-            self.state.memory.store(
-                endptr, nptr + num_bytes, condition=(endptr != 0), endness=self.state.arch.memory_endness
-            )
-            return self.state.solver.If(expression, value, 0)
+        expression, value, num_bytes = self.strtol_inner(nptr, self.state, self.state.memory, base, True)
+        self.state.memory.store(
+            endptr, nptr + num_bytes, condition=(endptr != 0), endness=self.state.arch.memory_endness
+        )
+        return claripy.If(expression, value, 0)

angr/procedures/libc/strtoul.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 
@@ -5,5 +6,4 @@ class strtoul(angr.SimProcedure):
     # pylint:disable=arguments-differ
     def run(self, nptr, endptr, base):
         strtol = angr.SIM_PROCEDURES["libc"]["strtol"]
-        result = self.inline_call(strtol, nptr, endptr, base).ret_expr
-        return result
+        return self.inline_call(strtol, nptr, endptr, base).ret_expr

angr/procedures/libc/system.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 import logging

angr/procedures/libc/time.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 
@@ -5,5 +6,4 @@ class time(angr.SimProcedure):
     # pylint:disable=arguments-differ
     def run(self, time_ptr):
         linux_time = angr.SIM_PROCEDURES["linux_kernel"]["time"]
-        result = self.inline_call(linux_time, time_ptr).ret_expr
-        return result
+        return self.inline_call(linux_time, time_ptr).ret_expr

angr/procedures/libc/tmpnam.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 import tempfile
 

angr/procedures/libc/tolower.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+import claripy
+
 import angr
 
 
 class tolower(angr.SimProcedure):
     # pylint: disable=arguments-differ
     def run(self, c):
-        return self.state.solver.If(self.state.solver.And(c >= 65, c <= 90), c + 32, c)  # A - Z
+        return claripy.If(claripy.And(c >= 65, c <= 90), c + 32, c)  # A - Z

angr/procedures/libc/toupper.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+import claripy
+
 import angr
 
 
 class toupper(angr.SimProcedure):
     # pylint: disable=arguments-differ
     def run(self, c):
-        return self.state.solver.If(self.state.solver.And(c >= 97, c <= 122), c - 32, c)  # a - z
+        return claripy.If(claripy.And(c >= 97, c <= 122), c - 32, c)  # a - z

angr/procedures/libc/ungetc.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 from cle.backends.externs.simdata.io_file import io_file_data_for_arch

angr/procedures/libc/vsnprintf.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libc/wchar.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/_unwind_resume.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/std____throw_bad_alloc.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/std____throw_bad_cast.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/std____throw_length_error.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/std____throw_logic_error.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/libstdcpp/std__terminate.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/linux_kernel/access.py

@@ -1,4 +1,5 @@
 # pylint:disable=arguments-differ,unused-argument,missing-class-docstring
+from __future__ import annotations
 import angr
 
 

angr/procedures/linux_kernel/arch_prctl.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/linux_kernel/arm_user_helpers.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 # references:

angr/procedures/linux_kernel/brk.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 import logging
 

angr/procedures/linux_kernel/cwd.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 import logging
 

angr/procedures/linux_kernel/fstat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 import angr
 
@@ -18,7 +19,7 @@ class fstat(angr.SimProcedure):
         elif self.state.arch.name == "AARCH64":
             self._store_aarch64(stat_buf, stat)
         else:
-            raise angr.errors.SimProcedureError("unsupported fstat arch: %s" % self.state.arch)
+            raise angr.errors.SimProcedureError(f"unsupported fstat arch: {self.state.arch}")
         return result
 
     def _store_amd64(self, stat_buf, stat):
@@ -31,7 +32,7 @@ class fstat(angr.SimProcedure):
         store(0x18, stat.st_mode)
         store(0x1C, stat.st_uid)
         store(0x20, stat.st_gid)
-        store(0x24, self.state.solver.BVV(0, 32))
+        store(0x24, claripy.BVV(0, 32))
         store(0x28, stat.st_rdev)
         store(0x30, stat.st_size)
         store(0x38, stat.st_blksize)
@@ -42,9 +43,9 @@ class fstat(angr.SimProcedure):
         store(0x60, stat.st_mtimensec)
         store(0x68, stat.st_ctime)
         store(0x70, stat.st_ctimensec)
-        store(0x78, self.state.solver.BVV(0, 64))
-        store(0x80, self.state.solver.BVV(0, 64))
-        store(0x88, self.state.solver.BVV(0, 64))
+        store(0x78, claripy.BVV(0, 64))
+        store(0x80, claripy.BVV(0, 64))
+        store(0x88, claripy.BVV(0, 64))
 
         # return struct.pack('<QQQLLLxxxxQqqqQqQqQxxxxxxxxxxxxxxxxxxxxxxxx',
         #                    stat.st_dev,
@@ -84,23 +85,23 @@ class fstat(angr.SimProcedure):
         store(0x60, stat.st_mtimensec)
         store(0x68, stat.st_ctime)
         store(0x70, stat.st_ctimensec)
-        store(0x78, self.state.solver.BVV(0, 64))
-        store(0x80, self.state.solver.BVV(0, 64))
-        store(0x88, self.state.solver.BVV(0, 64))
+        store(0x78, claripy.BVV(0, 64))
+        store(0x80, claripy.BVV(0, 64))
+        store(0x88, claripy.BVV(0, 64))
 
     def _store_mips64(self, stat_buf, stat):
         def store(offset, val):
             return self.state.memory.store(stat_buf + offset, val, endness=self.state.arch.memory_endness)
 
         store(0x00, stat.st_dev)
-        store(0x04, self.state.solver.BVV(0, 32 * 3))
+        store(0x04, claripy.BVV(0, 32 * 3))
         store(0x10, stat.st_ino)
         store(0x18, stat.st_mode)
         store(0x1C, stat.st_nlink)
         store(0x20, stat.st_uid)
         store(0x24, stat.st_gid)
         store(0x28, stat.st_rdev)
-        store(0x2C, self.state.solver.BVV(0, 32 * 3))
+        store(0x2C, claripy.BVV(0, 32 * 3))
         store(0x38, stat.st_size)
         store(0x40, stat.st_atime)
         store(0x44, stat.st_atimensec)
@@ -109,7 +110,7 @@ class fstat(angr.SimProcedure):
         store(0x50, stat.st_ctime)
         store(0x54, stat.st_ctimensec)
         store(0x58, stat.st_blksize)
-        store(0x5C, self.state.solver.BVV(0, 32))
+        store(0x5C, claripy.BVV(0, 32))
         store(0x60, stat.st_blocks)
 
     def _store_aarch64(self, stat_buf, stat):
@@ -123,10 +124,10 @@ class fstat(angr.SimProcedure):
         store(0x18, stat.st_uid)
         store(0x1C, stat.st_gid)
         store(0x20, stat.st_rdev)
-        store(0x28, self.state.solver.BVV(0, 64))
+        store(0x28, claripy.BVV(0, 64))
         store(0x30, stat.st_size)
         store(0x38, stat.st_blksize)
-        store(0x3C, self.state.solver.BVV(0, 32))
+        store(0x3C, claripy.BVV(0, 32))
         store(0x40, stat.st_blocks)
         store(0x48, stat.st_atime)
         store(0x50, stat.st_atimensec)
@@ -134,4 +135,4 @@ class fstat(angr.SimProcedure):
         store(0x60, stat.st_mtimensec)
         store(0x68, stat.st_ctime)
         store(0x70, stat.st_ctimensec)
-        store(0x78, self.state.solver.BVV(0, 64))
+        store(0x78, claripy.BVV(0, 64))