angr 9.2.115__py3-none-macosx_11_0_arm64.whl → 9.2.117__py3-none-macosx_11_0_arm64.whl

angr/procedures/libc/strncmp.py

@@ -1,7 +1,9 @@
-import angr
-
 import logging
 
+import claripy
+
+import angr
+
 l = logging.getLogger(name=__name__)
 
 
@@ -50,9 +52,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,7 +64,7 @@ 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)
+                return claripy.BVV(0, 32)
             elif (
                 self.state.solver.single_valued(a_len)
                 and self.state.solver.single_valued(b_len)
@@ -70,14 +72,14 @@ class strncmp(angr.SimProcedure):
             ):
                 # two empty strings
                 l.debug("returning equal for two empty strings")
-                return self.state.solver.BVV(0, 32)
+                return claripy.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)
+                    return claripy.BVV(-1, 32)
                 else:
-                    return self.state.solver.BVV(1, 32)
+                    return claripy.BVV(1, 32)
 
         # the bytes
         max_byte_len = maxlen * char_size
@@ -111,9 +113,9 @@ class strncmp(angr.SimProcedure):
                 if a_conc != b_conc:
                     l.debug("... found mis-matching concrete bytes 0x%x and 0x%x", a_conc, b_conc)
                     if a_conc < b_conc:
-                        return self.state.solver.BVV(-1, 32)
+                        return claripy.BVV(-1, 32)
                     else:
-                        return self.state.solver.BVV(1, 32)
+                        return claripy.BVV(1, 32)
             else:
                 if self.state.mode == "static":
                     return_values.append(a_byte - b_byte)
@@ -122,17 +124,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 +142,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 +164,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,9 @@
-import angr
 import logging
 
+import claripy
+
+import angr
+
 l = logging.getLogger(name=__name__)
 
 
@@ -12,7 +15,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/strstr.py

@@ -1,7 +1,10 @@
+import logging
+
+import claripy
+
 import angr
 from angr.sim_options import MEMORY_CHUNK_INDIVIDUAL_READS
 
-import logging
 
 l = logging.getLogger(name=__name__)
 
@@ -27,7 +30,7 @@ class strstr(angr.SimProcedure):
             return haystack_addr
         elif 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,9 +52,9 @@ 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]
+                        [claripy.UGE(haystack_strlen.ret_expr, needle_strlen.ret_expr), cmp_res.ret_expr == 0]
                         + not_terminated_yet_constraints
                         + exclusions
                     )
@@ -69,10 +72,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

@@ -49,9 +49,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 +66,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 +92,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 +115,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():
@@ -136,13 +136,13 @@ class strtol(angr.SimProcedure):
                 # 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 +154,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 +215,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 +237,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
@@ -260,4 +258,4 @@ class strtol(angr.SimProcedure):
             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)
+            return claripy.If(expression, value, 0)

angr/procedures/libc/tolower.py

@@ -1,7 +1,9 @@
+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,9 @@
+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/linux_kernel/fstat.py

@@ -31,7 +31,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 +42,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 +84,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 +109,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 +123,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 +134,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))

angr/procedures/linux_kernel/fstat64.py

@@ -62,7 +62,7 @@ class fstat64(angr.SimProcedure):
         store(0x2C, stat.st_size)
         store(0x34, stat.st_blksize)
         store(0x38, stat.st_blocks)
-        store(0x3C, self.state.solver.BVV(0, 32))  # padding
+        store(0x3C, claripy.BVV(0, 32))  # padding
         store(0x40, stat.st_atime)
         store(0x44, stat.st_atimensec)
         store(0x48, stat.st_mtime)
@@ -81,7 +81,7 @@ class fstat64(angr.SimProcedure):
         store(0x18, stat.st_nlink)
         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)
@@ -92,9 +92,9 @@ class fstat64(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_ppc32(self, stat_buf, stat):
         def store(offset, val):
@@ -107,10 +107,10 @@ class fstat64(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(0x4C, stat.st_atimensec)
@@ -118,20 +118,20 @@ class fstat64(angr.SimProcedure):
         store(0x54, stat.st_mtimensec)
         store(0x58, stat.st_ctime)
         store(0x5C, stat.st_ctimensec)
-        store(0x60, self.state.solver.BVV(0, 32))
-        store(0x64, self.state.solver.BVV(0, 32))
+        store(0x60, claripy.BVV(0, 32))
+        store(0x64, claripy.BVV(0, 32))
 
     def _store_mips32(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_uid)
         store(0x1C, stat.st_gid)
         store(0x20, stat.st_rdev)
-        store(0x24, self.state.solver.BVV(0, 32 * 3))
+        store(0x24, claripy.BVV(0, 32 * 3))
         store(0x30, stat.st_size)
         store(0x38, stat.st_atime)
         store(0x3C, stat.st_atimensec)
@@ -140,7 +140,7 @@ class fstat64(angr.SimProcedure):
         store(0x48, stat.st_ctime)
         store(0x4C, stat.st_ctimensec)
         store(0x50, stat.st_blksize)
-        store(0x54, self.state.solver.BVV(0, 32))
+        store(0x54, claripy.BVV(0, 32))
         store(0x58, stat.st_blocks)
 
     def _store_arm_eabi(self, stat_buf, stat):
@@ -148,18 +148,18 @@ class fstat64(angr.SimProcedure):
             return self.state.memory.store(stat_buf + offset, val, endness=self.state.arch.memory_endness)
 
         store(0x00, stat.st_dev)
-        store(0x02, self.state.solver.BVV(0, 8 * 10))
+        store(0x02, claripy.BVV(0, 8 * 10))
         store(0x0C, stat.st_ino)
         store(0x10, stat.st_mode)
         store(0x14, stat.st_nlink)
         store(0x18, stat.st_uid)
         store(0x1C, stat.st_gid)
         store(0x20, stat.st_rdev)
-        store(0x22, self.state.solver.BVV(0, 8 * 10))
+        store(0x22, claripy.BVV(0, 8 * 10))
         store(0x2C, stat.st_size)
         store(0x34, stat.st_blksize)
         store(0x38, stat.st_blocks)
-        store(0x3C, self.state.solver.BVV(0, 32))
+        store(0x3C, claripy.BVV(0, 32))
         store(0x40, stat.st_atime)
         store(0x44, stat.st_atimensec)
         store(0x48, stat.st_mtime)

angr/procedures/linux_kernel/lseek.py

@@ -1,7 +1,9 @@
-import angr
-
 import logging
 
+import claripy
+
+import angr
+
 l = logging.getLogger(name=__name__)
 
 
@@ -36,4 +38,4 @@ class lseek(angr.SimProcedure):
         success = simfd.seek(seek, whence_str)
         if self.state.solver.is_false(success):
             return -1
-        return self.state.solver.If(success, simfd.tell(), -1)
+        return claripy.If(success, simfd.tell(), -1)

angr/procedures/linux_kernel/sigaction.py

@@ -1,10 +1,12 @@
+import claripy
+
 import angr
 
 
 class sigaction(angr.SimProcedure):
     def run(self, signum, act, oldact):  # pylint:disable=arguments-differ,unused-argument
         # TODO: actually do something
-        return self.state.solver.BVV(0, self.arch.sizeof["long"])
+        return claripy.BVV(0, self.arch.sizeof["long"])
 
 
 class rt_sigaction(angr.SimProcedure):
@@ -13,4 +15,4 @@ class rt_sigaction(angr.SimProcedure):
         # ...hack
         if self.state.solver.is_true(signum == 33):
             return self.state.libc.ret_errno("EINVAL")
-        return self.state.solver.BVV(0, self.arch.sizeof["long"])
+        return claripy.BVV(0, self.arch.sizeof["long"])

angr/procedures/linux_kernel/sigprocmask.py

@@ -1,3 +1,5 @@
+import claripy
+
 import angr
 
 
@@ -9,12 +11,12 @@ class sigprocmask(angr.SimProcedure):
         self.state.posix.sigprocmask(how, self.state.memory.load(set_, sigsetsize), sigsetsize, valid_ptr=set_ != 0)
 
         # TODO: EFAULT
-        return self.state.solver.If(
-            self.state.solver.And(
+        return claripy.If(
+            claripy.And(
                 how != self.state.posix.SIG_BLOCK,
                 how != self.state.posix.SIG_UNBLOCK,
                 how != self.state.posix.SIG_SETMASK,
             ),
-            self.state.solver.BVV(self.state.posix.EINVAL, self.arch.sizeof["int"]),
+            claripy.BVV(self.state.posix.EINVAL, self.arch.sizeof["int"]),
             0,
         )

angr/procedures/linux_kernel/tgkill.py

@@ -1,7 +1,9 @@
+import claripy
+
 import angr
 
 
 class tgkill(angr.SimProcedure):
     def run(self, tgid, tid, sig):  # pylint:disable=arguments-differ,unused-argument
         # TODO: actually do something
-        return self.state.solver.BVV(0, self.arch.sizeof["int"])
+        return claripy.BVV(0, self.arch.sizeof["int"])

angr/procedures/linux_kernel/time.py

@@ -1,5 +1,8 @@
+import time as py_time
+
+import claripy
+
 import angr
-import time as _time
 
 
 class time(angr.SimProcedure):
@@ -17,10 +20,10 @@ class time(angr.SimProcedure):
     def run(self, pointer):
         # TODO lord have mercy. how big is time_t?
         if angr.options.USE_SYSTEM_TIMES in self.state.options:
-            ts = int(_time.time())
-            result = self.state.solver.BVV(ts, self.state.arch.bits)
+            ts = int(py_time.time())
+            result = claripy.BVV(ts, self.state.arch.bits)
         else:
-            result = self.state.solver.BVS("sys_time", self.state.arch.bits, key=("api", "time"))
+            result = claripy.BVS("sys_time", self.state.arch.bits, key=("api", "time"))
             if self.last_time is not None:
                 self.state.add_constraints(result.SGE(self.last_time))
             else:

angr/procedures/msvcr/fmode.py

@@ -1,3 +1,5 @@
+import claripy
+
 import angr
 
 
@@ -17,7 +19,7 @@ class _get_fmode(angr.SimProcedure):
 
 class _set_fmode(angr.SimProcedure):
     def run(self, val):
-        if not self.state.solver.is_true(self.state.solver.Or(val == 0x4000, val == 0x8000)):
+        if not self.state.solver.is_true(claripy.Or(val == 0x4000, val == 0x8000)):
             return 22
         self.state.mem[self.project.simos.fmode_ptr].int = val
         return 0