angr 9.2.116__py3-none-manylinux2014_aarch64.whl → 9.2.117__py3-none-manylinux2014_aarch64.whl

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

angr/procedures/ntdll/exceptions.py

@@ -1,3 +1,5 @@
+import claripy
+
 import angr
 
 
@@ -13,7 +15,7 @@ class KiUserExceptionDispatcher(angr.SimProcedure):
         if self.state.arch.name != "X86":
             raise angr.errors.SimUnsupportedError("KiUserDispatchException is only implemented for X86")
 
-        self.tib_ptr = self.state.regs._fs.concat(self.state.solver.BVV(0, 16))
+        self.tib_ptr = self.state.regs._fs.concat(claripy.BVV(0, 16))
         self.top_record = self.state.mem[self.tib_ptr].uint32_t.resolved
         self.cur_ptr = self.top_record
 

angr/procedures/posix/bzero.py

@@ -1,6 +1,8 @@
+import claripy
+
 from ..libc import memset
 
 
 class bzero(memset.memset):
     def run(self, addr, size):
-        return super().run(addr, self.state.solver.BVV(0, self.arch.byte_width), size)
+        return super().run(addr, claripy.BVV(0, self.arch.byte_width), size)

angr/procedures/posix/fdopen.py

@@ -1,6 +1,8 @@
+import claripy
+from cle.backends.externs.simdata.io_file import io_file_data_for_arch
+
 import angr
 
-from cle.backends.externs.simdata.io_file import io_file_data_for_arch
 
 # Reference for implementation: glibc-2.25/libio/iofdopen.c
 
@@ -65,7 +67,7 @@ class fdopen(angr.SimProcedure):
             file_struct_ptr = self.inline_call(malloc, io_file_data["size"]).ret_expr
 
             # Write the fd
-            fd_bvv = self.state.solver.BVV(fd_concr, 4 * 8)  # int
+            fd_bvv = claripy.BVV(fd_concr, 4 * 8)  # int
             self.state.memory.store(
                 file_struct_ptr + io_file_data["fd"], fd_bvv, endness=self.state.arch.memory_endness
             )
@@ -73,5 +75,5 @@ class fdopen(angr.SimProcedure):
             if self.state.solver.is_true(fd_int == fd_concr):
                 return file_struct_ptr
             else:
-                null = self.state.solver.BVV(0, self.state.arch.bits)
-                return self.state.solver.If(fd_int == fd_concr, file_struct_ptr, null)
+                null = claripy.BVV(0, self.state.arch.bits)
+                return claripy.If(fd_int == fd_concr, file_struct_ptr, null)

angr/procedures/posix/fork.py

@@ -1,10 +1,12 @@
+import claripy
+
 import angr
 
 
 class fork(angr.SimProcedure):
     def run(self):
-        return self.state.solver.If(
-            self.state.solver.BoolS("fork_parent"),
-            self.state.solver.BVV(1338, self.arch.sizeof["int"]),
-            self.state.solver.BVV(0, self.arch.sizeof["int"]),
+        return claripy.If(
+            claripy.BoolS("fork_parent"),
+            claripy.BVV(1338, self.arch.sizeof["int"]),
+            claripy.BVV(0, self.arch.sizeof["int"]),
         )

angr/procedures/posix/mmap.py

@@ -1,7 +1,10 @@
+import logging
+
+import claripy
+
 import angr
 from ...storage.file import SimFileDescriptor
 
-import logging
 
 l = logging.getLogger(name=__name__)
 
@@ -89,7 +92,7 @@ class mmap(angr.SimProcedure):
         # Sanity check. All mmap must have exactly one of MAP_SHARED or MAP_PRIVATE
         if (flags & MAP_SHARED and flags & MAP_PRIVATE) or flags & (MAP_SHARED | MAP_PRIVATE) == 0:
             l.debug("... = -1 (bad flags)")
-            return self.state.solver.BVV(-1, self.state.arch.bits)
+            return claripy.BVV(-1, self.state.arch.bits)
 
         # Do region mapping
         while True:
@@ -103,7 +106,7 @@ class mmap(angr.SimProcedure):
 
                 if flags & MAP_FIXED:
                     l.debug("... = -1 (MAP_FIXED failure)")
-                    return self.state.solver.BVV(-1, self.state.arch.bits)
+                    return claripy.BVV(-1, self.state.arch.bits)
 
                 # Can't give you that address. Find a different one and loop back around to try again.
                 addr = self.allocate_memory(size)

angr/procedures/posix/poll.py

@@ -1,6 +1,9 @@
-import angr
 import select
 
+import claripy
+
+import angr
+
 
 class poll(angr.SimProcedure):
     # pylint:disable=arguments-differ
@@ -43,12 +46,10 @@ class poll(angr.SimProcedure):
                 raise angr.errors.SimProcedureArgumentError("Can't handle symbolic pollfd arguments") from e
 
             if events & select.POLLIN and fd >= 0:
-                revents = pollfd["revents"][self.arch.sizeof["short"] - 1 : 1].concat(
-                    self.state.solver.BVS("fd_POLLIN", 1)
-                )
+                revents = pollfd["revents"][self.arch.sizeof["short"] - 1 : 1].concat(claripy.BVS("fd_POLLIN", 1))
                 self.state.memory.store(
                     fds + offset * size_of_pollfd + offset_revents, revents, endness=self.arch.memory_endness
                 )
 
-        retval = self.state.solver.BVV(0, 1).concat(self.state.solver.BVS("poll_ret", self.state.arch.bits - 1))
+        retval = claripy.BVV(0, 1).concat(claripy.BVS("poll_ret", self.state.arch.bits - 1))
         return retval